Changed rest note (#4837)

* Changed rest term

* Update quantum/audio/musical_notes.h

Co-Authored-By: germ <[email protected]>

keyboards/crkbd/keymaps/omgvee/config.h

@@ -0,0 +1,45 @@
+/*
+This is the c configuration file for the keymap
+
+Copyright 2012 Jun Wako <[email protected]>
+Copyright 2015 Jack Humbert
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+//#define USE_MATRIX_I2C
+
+/* Select hand configuration */
+
+#define MASTER_LEFT
+// #define MASTER_RIGHT
+// #define EE_HANDS
+
+#define SSD1306OLED
+
+#define USE_SERIAL_PD2
+
+#define TAPPING_FORCE_HOLD
+#define TAPPING_TERM 100
+
+#undef RGBLED_NUM
+#define RGBLIGHT_ANIMATIONS
+#define RGBLED_NUM 27
+#define RGBLIGHT_LIMIT_VAL 120
+#define RGBLIGHT_HUE_STEP 10
+#define RGBLIGHT_SAT_STEP 17
+#define RGBLIGHT_VAL_STEP 17
+#define BACKLIGHT_LEVELS 10

keyboards/crkbd/keymaps/omgvee/keymap.c

@@ -0,0 +1,239 @@
+#include QMK_KEYBOARD_H
+#include "bootloader.h"
+#ifdef PROTOCOL_LUFA
+  #include "lufa.h"
+  #include "split_util.h"
+#endif
+#ifdef SSD1306OLED
+  #include "ssd1306.h"
+#endif
+
+extern keymap_config_t keymap_config;
+
+#ifdef RGBLIGHT_ENABLE
+//Following line allows macro to read current RGB settings
+extern rgblight_config_t rgblight_config;
+#endif
+
+extern uint8_t is_master;
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+#define _QWERTY 0
+#define _LOWER 3
+#define _RAISE 4
+#define _ADJUST 16
+
+enum custom_keycodes {
+  QWERTY = SAFE_RANGE,
+  LOWER,
+  RAISE,
+  ADJUST,
+  BACKLIT,
+  RGBRST
+};
+
+enum macro_keycodes {
+  KC_SAMPLEMACRO,
+};
+
+#define KC______ KC_TRNS
+#define KC_XXXXX KC_NO
+#define KC_LOWER LOWER
+#define KC_RAISE RAISE
+#define KC_RST   RESET
+#define KC_LRST  RGBRST
+#define KC_LTOG  RGB_TOG
+#define KC_LHUI  RGB_HUI
+#define KC_LHUD  RGB_HUD
+#define KC_LSAI  RGB_SAI
+#define KC_LSAD  RGB_SAD
+#define KC_LVAI  RGB_VAI
+#define KC_LVAD  RGB_VAD
+#define KC_LMOD  RGB_MOD
+#define KC_SFCPS SFT_T(KC_CAPS)
+#define KC_CTLTB CTL_T(KC_TAB)
+#define KC_GUIEI GUI_T(KC_LANG2)
+#define KC_ALTKN ALT_T(KC_LANG1)
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  [_QWERTY] = LAYOUT_kc( \
+  //,-----------------------------------------.                ,-----------------------------------------.
+        ESC,     Q,     W,     E,     R,     T,                      Y,     U,     I,     O,     P,  BSPC,\
+  //|------+------+------+------+------+------|                |------+------+------+------+------+------|
+      SFCPS,     A,     S,     D,     F,     G,                      H,     J,     K,     L,  SCLN,  QUOT,\
+  //|------+------+------+------+------+------|                |------+------+------+------+------+------|
+      CTLTB,     Z,     X,     C,     V,     B,                      N,     M,  COMM,   DOT,  SLSH,  RSFT,\
+  //|------+------+------+------+------+------+------|  |------+------+------+------+------+------+------|
+                                  GUIEI, LOWER,   ENT,      SPC, RAISE, ALTKN \
+                              //`--------------------'  `--------------------'
+  ),
+
+  [_LOWER] = LAYOUT_kc( \
+  //,-----------------------------------------.                ,-----------------------------------------.
+        GRV,     1,     2,     3,     4,     5,                      6,     7,     8,     9,     0,  BSPC,\
+  //|------+------+------+------+------+------|                |------+------+------+------+------+------|
+      SFCPS,    F1,    F2,    F3,    F4,    F5,                     F6,    F7,    F8,    F9,   F10,   ENT,\
+  //|------+------+------+------+------+------|                |------+------+------+------+------+------|
+      CTLTB,   F11,   F12,   F13,   F14,   F15,                    F16,   F17,   F18,   F19,   F20,  RSFT,\
+  //|------+------+------+------+------+------+------|  |------+------+------+------+------+------+------|
+                                  GUIEI, LOWER,   ENT,      SPC, RAISE, ALTKN \
+                              //`--------------------'  `--------------------'
+  ),
+
+  [_RAISE] = LAYOUT_kc( \
+  //,-----------------------------------------.                ,-----------------------------------------.
+        TAB,  EXLM,    AT,  HASH,   DLR,  PERC,                   CIRC,  AMPR,  ASTR,  LPRN,  RPRN,  BSPC,\
+  //|------+------+------+------+------+------|                |------+------+------+------+------+------|
+      SFCPS, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX,                   MINS,   EQL,  LCBR,  RCBR,  PIPE,  BSLS,\
+  //|------+------+------+------+------+------|                |------+------+------+------+------+------|
+      CTLTB, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX,                   UNDS,  PLUS,  LBRC,  RBRC,  SLSH,  RSFT,\
+  //|------+------+------+------+------+------+------|  |------+------+------+------+------+------+------|
+                                  GUIEI, LOWER,   ENT,      SPC, RAISE, ALTKN \
+                              //`--------------------'  `--------------------'
+  ),
+
+  [_ADJUST] = LAYOUT_kc( \
+  //,-----------------------------------------.                ,-----------------------------------------.
+        RST,  LRST, XXXXX, XXXXX, XXXXX, XXXXX,                  XXXXX, XXXXX, XXXXX, XXXXX, XXXXX, XXXXX,\
+  //|------+------+------+------+------+------|                |------+------+------+------+------+------|
+       LTOG,  LHUI,  LSAI,  LVAI, XXXXX, XXXXX,                   LEFT,  DOWN,    UP, RIGHT, XXXXX, XXXXX,\
+  //|------+------+------+------+------+------|                |------+------+------+------+------+------|
+       LMOD,  LHUD,  LSAD,  LVAD, XXXXX, XXXXX,                   BRID,  BRIU,  VOLD,  VOLU,  MUTE, XXXXX,\
+  //|------+------+------+------+------+------+------|  |------+------+------+------+------+------+------|
+                                  GUIEI, LOWER,   ENT,      SPC, RAISE, ALTKN \
+                              //`--------------------'  `--------------------'
+  )
+};
+
+int RGB_current_mode;
+
+// Setting ADJUST layer RGB back to default
+void update_tri_layer_RGB(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
+  if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
+    layer_on(layer3);
+  } else {
+    layer_off(layer3);
+  }
+}
+
+void matrix_init_user(void) {
+    #ifdef RGBLIGHT_ENABLE
+      RGB_current_mode = rgblight_config.mode;
+    #endif
+    //SSD1306 OLED init, make sure to add #define SSD1306OLED in config.h
+    #ifdef SSD1306OLED
+        iota_gfx_init(!has_usb());   // turns on the display
+    #endif
+}
+
+//SSD1306 OLED update loop, make sure to add #define SSD1306OLED in config.h
+#ifdef SSD1306OLED
+
+// When add source files to SRC in rules.mk, you can use functions.
+const char *read_layer_state(void);
+const char *read_logo(void);
+void set_keylog(uint16_t keycode, keyrecord_t *record);
+const char *read_keylog(void);
+const char *read_keylogs(void);
+
+// const char *read_mode_icon(bool swap);
+// const char *read_host_led_state(void);
+// void set_timelog(void);
+// const char *read_timelog(void);
+
+void matrix_scan_user(void) {
+   iota_gfx_task();
+}
+
+void matrix_render_user(struct CharacterMatrix *matrix) {
+  if (is_master) {
+    // If you want to change the display of OLED, you need to change here
+    matrix_write_ln(matrix, read_layer_state());
+    matrix_write_ln(matrix, read_keylog());
+    matrix_write_ln(matrix, read_keylogs());
+    //matrix_write_ln(matrix, read_mode_icon(keymap_config.swap_lalt_lgui));
+    //matrix_write_ln(matrix, read_host_led_state());
+    //matrix_write_ln(matrix, read_timelog());
+  } else {
+    matrix_write(matrix, read_logo());
+  }
+}
+
+void matrix_update(struct CharacterMatrix *dest, const struct CharacterMatrix *source) {
+  if (memcmp(dest->display, source->display, sizeof(dest->display))) {
+    memcpy(dest->display, source->display, sizeof(dest->display));
+    dest->dirty = true;
+  }
+}
+
+void iota_gfx_task_user(void) {
+  struct CharacterMatrix matrix;
+  matrix_clear(&matrix);
+  matrix_render_user(&matrix);
+  matrix_update(&display, &matrix);
+}
+#endif//SSD1306OLED
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  if (record->event.pressed) {
+#ifdef SSD1306OLED
+    set_keylog(keycode, record);
+#endif
+    // set_timelog();
+  }
+
+  switch (keycode) {
+    case LOWER:
+      if (record->event.pressed) {
+        layer_on(_LOWER);
+        update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
+      } else {
+        layer_off(_LOWER);
+        update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
+      }
+      return false;
+      break;
+    case RAISE:
+      if (record->event.pressed) {
+        layer_on(_RAISE);
+        update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
+      } else {
+        layer_off(_RAISE);
+        update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
+      }
+      return false;
+      break;
+    case ADJUST:
+        if (record->event.pressed) {
+          layer_on(_ADJUST);
+        } else {
+          layer_off(_ADJUST);
+        }
+        return false;
+        break;
+    case RGB_MOD:
+      #ifdef RGBLIGHT_ENABLE
+        if (record->event.pressed) {
+          rgblight_mode(RGB_current_mode);
+          rgblight_step();
+          RGB_current_mode = rgblight_config.mode;
+        }
+      #endif
+      return false;
+      break;
+    case RGBRST:
+      #ifdef RGBLIGHT_ENABLE
+        if (record->event.pressed) {
+          eeconfig_update_rgblight_default();
+          rgblight_enable();
+          RGB_current_mode = rgblight_config.mode;
+        }
+      #endif
+      break;
+  }
+  return true;
+}
+

keyboards/crkbd/keymaps/omgvee/readme.md

@@ -0,0 +1,15 @@
+# Reade.md for what I want from my HeliDox(CRKBD) layout
+======================================================
+
+
+![My beloved HeliDox keeb](https://imgur.com/a/t5m6rmW)
+
+- media keys and media controls
+- in-switch LED intensity controls (+/-)
+- underglow RGB hue/color controls
+- underglow RGB intensity controls
+- familiar key arrangement with Enter and symbols on the usual keys (to the right hand side)
+- navigation keys should be the vim ones really;
+- arrow keys on one layer(most likely on the ADJUST one)
+
+See keymap.c for layouts

keyboards/crkbd/keymaps/omgvee/rules.mk

@@ -0,0 +1,31 @@
+
+# Build Options
+#   change to "no" to disable the options, or define them in the Makefile in
+#   the appropriate keymap folder that will get included automatically
+#
+BOOTMAGIC_ENABLE = no       # Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE = no       # Mouse keys(+4700)
+EXTRAKEY_ENABLE = no       # Audio control and System control(+450)
+CONSOLE_ENABLE = no         # Console for debug(+400)
+COMMAND_ENABLE = no         # Commands for debug and configuration
+NKRO_ENABLE = no           # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+BACKLIGHT_ENABLE = yes      # Enable keyboard backlight functionality
+MIDI_ENABLE = no            # MIDI controls
+AUDIO_ENABLE = no           # Audio output on port C6
+UNICODE_ENABLE = no         # Unicode
+BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
+RGBLIGHT_ENABLE = yes       # Enable WS2812 RGB underlight. 
+SWAP_HANDS_ENABLE = no      # Enable one-hand typing
+
+# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
+SLEEP_LED_ENABLE = no    # Breathing sleep LED during USB suspend
+
+# If you want to change the display of OLED, you need to change here
+SRC +=  ./lib/glcdfont.c \
+        ./lib/rgb_state_reader.c \
+        ./lib/layer_state_reader.c \
+        ./lib/logo_reader.c \
+        ./lib/keylogger.c \
+        # ./lib/mode_icon_reader.c \
+        # ./lib/host_led_state_reader.c \
+        # ./lib/timelogger.c \

keyboards/gergo/info.json

@@ -5,7 +5,7 @@
     "keyboard_name": "Gergo",
     "url": "http://gboards.ca",
     "layouts": {
-        "LAYOUT": {
+        "LAYOUT_GERGO": {
             "layout": [
                 {
                     "label": "L00",

keyboards/handwired/hexon38/config.h

@@ -0,0 +1,60 @@
+// see https://github.com/pepaslabs/hexon38
+
+#pragma once
+
+#include "config_common.h"
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID       0xFEED
+#define PRODUCT_ID      0x6060
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    pepaslabs
+#define PRODUCT         hexon38
+#define DESCRIPTION     "A handmade non-split ergonomic 38-key keyboard, inspired by the lil38.  See https://github.com/pepaslabs/hexon38."
+
+/* key matrix size */
+#define MATRIX_ROWS 4
+#define MATRIX_COLS 12
+
+/* key matrix pins */
+#define MATRIX_ROW_PINS { B0, F0, B2, F4 }
+#define MATRIX_COL_PINS { C6, D3, D2, D1, D0, B7, F6, F7, B6, B5, B4, D7 }
+#define UNUSED_PINS
+
+/* COL2ROW or ROW2COL */
+#define DIODE_DIRECTION ROW2COL
+
+/* number of backlight levels */
+
+#ifdef BACKLIGHT_PIN
+#define BACKLIGHT_LEVELS 0
+#endif
+
+/* Set 0 if debouncing isn't needed */
+#define DEBOUNCING_DELAY 5
+
+
+/* key combination for command */
+#define IS_COMMAND() ( \
+    keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
+)
+
+#ifdef RGB_DI_PIN
+#define RGBLIGHT_ANIMATIONS
+#define RGBLED_NUM 0
+#define RGBLIGHT_HUE_STEP 8
+#define RGBLIGHT_SAT_STEP 8
+#define RGBLIGHT_VAL_STEP 8
+#endif
+
+
+// Disabled features:
+
+/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
+//#define LOCKING_SUPPORT_ENABLE
+
+/* Locking resynchronize hack */
+//#define LOCKING_RESYNC_ENABLE
+
+/* prevent stuck modifiers */
+//#define PREVENT_STUCK_MODIFIERS

keyboards/handwired/hexon38/hexon38.c

@@ -0,0 +1,3 @@
+// see https://github.com/pepaslabs/hexon38
+
+#include "hexon38.h"

keyboards/handwired/hexon38/hexon38.h

@@ -0,0 +1,17 @@
+// see https://github.com/pepaslabs/hexon38
+
+#pragma once
+
+#include "quantum.h"
+
+#define LAYOUT( \
+	            K002, K003, K004, K005, K006, K007, K008, K009,             \
+	K100, K101, K102, K103, K104, K105, K106, K107, K108, K109, K110, K111, \
+	K200, K201, K202, K203, K204,             K207, K208, K209, K210, K211, \
+	            K302, K303, K304, K305, K306, K307, K308, K309  \
+) { \
+	{ KC_NO, KC_NO, K002,  K003,  K004,  K005,  K006,  K007,  K008,  K009,  KC_NO, KC_NO }, \
+	{ K100,  K101,  K102,  K103,  K104,  K105,  K106,  K107,  K108,  K109,  K110,  K111 }, \
+	{ K200,  K201,  K202,  K203,  K204,  KC_NO, KC_NO, K207,  K208,  K209,  K210,  K211 }, \
+	{ KC_NO, KC_NO, K302,  K303,  K304,  K305,  K306,  K307,  K308,  K309,  KC_NO, KC_NO }  \
+}

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

@@ -0,0 +1,407 @@
+// see https://github.com/pepaslabs/hexon38
+
+#include "hexon38.h"
+
+#define A_ KC_A
+#define B_ KC_B
+#define C_ KC_C
+#define D_ KC_D
+#define E_ KC_E
+#define F_ KC_F
+#define G_ KC_G
+#define H_ KC_H
+#define I_ KC_I
+#define J_ KC_J
+#define K_ KC_K
+#define L_ KC_L
+#define M_ KC_M
+#define N_ KC_N
+#define O_ KC_O
+#define P_ KC_P
+#define Q_ KC_Q
+#define R_ KC_R
+#define S_ KC_S
+#define T_ KC_T
+#define U_ KC_U
+#define V_ KC_V
+#define W_ KC_W
+#define X_ KC_X
+#define Y_ KC_Y
+#define Z_ KC_Z
+
+// Dual-role keys: modifier when held, alpha when tapped.
+#define A_CTL CTL_T(KC_A)
+#define S_ALT ALT_T(KC_S)
+#define D_GUI GUI_T(KC_D)
+#define F_SFT SFT_T(KC_F)
+#define J_SFT SFT_T(KC_J)
+#define K_GUI GUI_T(KC_K)
+#define L_ALT ALT_T(KC_L)
+#define COLN_CTL CTL_T(KC_SCLN)
+
+#define ______ KC_TRNS
+#define LSHIFT KC_LSHIFT
+#define RSHIFT KC_RSHIFT
+#define COMMA KC_COMM
+#define SLASH KC_SLSH
+#define SPACE KC_SPC
+#define TAB KC_TAB
+#define BKSPC KC_BSPC
+#define ENTER KC_ENT
+#define PERIOD KC_DOT
+
+#define BASE_LAYER LAYOUT
+#define BLANK_LAYER LAYOUT
+
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+    BASE_LAYER(
+//                  ,--------+--------+--------+--------.    ,--------+--------+--------+--------.
+                        W_   ,   E_   ,   R_   ,   T_   ,        Y_   ,   U_   ,   I_   ,   O_   ,
+//|--------+--------+--------+--------+--------+--------|    |--------+--------+--------+--------+--------+--------.
+      Q_   ,  A_CTL ,  S_ALT ,  D_GUI ,  F_SFT ,   G_   ,        H_   ,  J_SFT ,  K_GUI ,  L_ALT ,COLN_CTL,   P_   ,
+//|--------+--------+--------+--------+--------+--------'    `--------+--------+--------+--------+--------+--------|
+      B_   ,   Z_   ,   X_   ,   C_   ,   V_   ,                          M_   ,  COMMA , PERIOD ,  SLASH ,   N_   ,
+//`--------+--------+--------+--------+--------'                      `--------+--------+--------+--------+--------'
+
+//                  ,--------+--------+--------+--------.    ,--------+--------+--------+--------.
+                      LSHIFT ,  SPACE ,   TAB  ,  DEBUG ,       SPACE ,  BKSPC ,  ENTER , RSHIFT
+//                  `--------+--------+--------+--------'    `--------+--------+--------+--------'
+),
+
+    BLANK_LAYER(
+//                  ,--------+--------+--------+--------.    ,--------+--------+--------+--------.
+                      ______ , ______ , ______ , ______ ,      ______ , ______ , ______ , ______ ,
+//|--------+--------+--------+--------+--------+--------|    |--------+--------+--------+--------+--------+--------.
+    ______ , ______ , ______ , ______ , ______ , ______ ,      ______ , ______ , ______ , ______ , ______ , ______ ,
+//|--------+--------+--------+--------+--------+--------'    `--------+--------+--------+--------+--------+--------|
+    ______ , ______ , ______ , ______ , ______ ,                        ______ , ______ , ______ , ______ , ______ ,
+//`--------+--------+--------+--------+--------'                      `--------+--------+--------+--------+--------'
+
+//                  ,--------+--------+--------+--------.    ,--------+--------+--------+--------.
+                      ______ , ______ , ______ , ______ ,      ______ , ______ , ______ , ______
+//                  `--------+--------+--------+--------'    `--------+--------+--------+--------'
+)
+
+};
+
+// a linked list of pending key events (press or release) which we haven't processed yet.
+struct _pending_key_t {
+    uint16_t keycode;
+    keyrecord_t record;
+    struct _pending_key_t *next;
+};
+typedef struct _pending_key_t pending_key_t;
+
+// worst case is 10 down strokes and 1 up stroke before we can start disambiguating.
+#define RINGSIZE 11
+
+// a ring buffer and linked list to store pending key events (presses and releases).
+// (basically, this is a fixed-allocation linked list.)
+struct _kring_t {
+    // the actual key events.
+    pending_key_t items[RINGSIZE];
+    // the index of the oldest item, or -1 if no items.
+    int8_t ifirst;
+    // the index of the most recently added item, or -1 if no items.
+    int8_t ilast;
+    // the number of items in the ring.
+    uint8_t count;
+    // the head of the linked list.
+    pending_key_t *head;
+};
+typedef struct _kring_t kring_t;
+
+// safe accessor to the i-th item of the linked list (returns pointer or NULL).
+pending_key_t* kring_get(kring_t *ring, uint8_t i) {
+    if (i >= ring->count) {
+        return NULL;
+    }
+    uint8_t j = (ring->ifirst + i) % RINGSIZE;
+    return &(ring->items[j]);
+}
+
+// return the last key in the list of buffered keys.
+pending_key_t* kring_last(kring_t *ring) {
+    if (ring->count == 0) {
+        return NULL;
+    }
+    return kring_get(ring, ring->count - 1);
+}
+
+// remove the oldest item from the ring (the head of the list).
+void kring_pop(kring_t *ring) {
+    if (ring->count > 0) {
+        ring->ifirst += 1;
+        ring->ifirst %= RINGSIZE;
+        ring->head = ring->head->next;
+        ring->count -= 1;
+    }
+}
+
+// add an item to the ring (append to the list).
+void kring_append(kring_t *ring, uint16_t keycode, keyrecord_t *record) {
+    if (ring->count >= RINGSIZE) {
+        // uh oh, we overflowed the capacity of our buffer :(
+        return;
+    }
+
+    // if the ring is empty, insert at index 0.
+    if (ring->count == 0) {
+        ring->count += 1;
+        ring->ifirst = 0;
+        ring->ilast = 0;
+        ring->head = &(ring->items[0]);
+    }
+    // else, append it onto the end.
+    else {
+        ring->count += 1;
+        ring->ilast += 1;
+        ring->ilast %= RINGSIZE;
+    }
+
+    // the index at which we should insert this item.
+    int8_t i = ring->ilast;
+
+    // insert the item.
+    ring->items[i].keycode = keycode;
+    ring->items[i].record.event = record->event;
+#ifndef NO_ACTION_TAPPING
+    ring->items[i].record.tap = record->tap;
+#endif
+    ring->items[i].next = NULL;
+
+    // update the previous item to point to this item.
+    if (ring->count > 1) {
+        kring_get(ring, ring->count - 2)->next = &(ring->items[i]);
+    }
+}
+
+kring_t g_pending;
+
+void matrix_init_user(void) {
+    g_pending.ifirst = -1;
+    g_pending.ilast = -1;
+    g_pending.count = 0;
+    g_pending.head = NULL;
+}
+
+void matrix_scan_user(void) {}
+
+/*
+a_ a-: emit a
+a_ b_ b- a-: emit SHIFT+b
+a_ b_ a- b-: emit a, b
+dual1down, dual1up -> norm1down, norm1up
+dual1down, norm2down, norm2up -> mod1down, norm2down, norm2up
+dual1down, norm2down, dual1up -> norm1down, norm2down, norm1up
+dual1down, dual2down, norm3down, norm3up -> mod1down, mod2down, norm3down, norm3up
+so, a dual key can't be disambiguated until the next keyup of a keydown (not including keyups from keys before it).
+*/
+
+bool is_ambiguous_kc(uint16_t kc) {
+    // See the MT() define: https://github.com/qmk/qmk_firmware/blob/master/quantum/quantum_keycodes.h#L642
+    // See the QK_MOD_TAP case: https://github.com/qmk/qmk_firmware/blob/master/quantum/keymap_common.c#L134
+    uint8_t mod = mod_config((kc >> 0x8) & 0x1F);
+    return mod != 0;
+}
+
+bool is_down(pending_key_t *k) {
+    return k->record.event.pressed;
+}
+
+bool is_up(pending_key_t *k) {
+    return !is_down(k);
+}
+
+bool keys_match(pending_key_t *a, pending_key_t *b) {
+    return a->record.event.key.col == b->record.event.key.col
+        && a->record.event.key.row == b->record.event.key.row;
+}
+
+// both the down and corresponding upstroke of a keypress.
+struct _pending_pair_t {
+    pending_key_t *down;
+    pending_key_t *up;
+};
+typedef struct _pending_pair_t pending_pair_t;
+
+// returns true if this keydown event has a corresponding keyup event in the
+// list of buffered keys.  also fills out 'p'.
+bool is_downup_pair(pending_key_t *k, pending_pair_t *p) {
+    // first, make sure this event is keydown.
+    if (!is_down(k)) {
+        return false;
+    }
+    // now find its matching keyup.
+    pending_key_t *next = k->next;
+    while (next != NULL) {
+        if (keys_match(k, next) && is_up(next)) {
+            // found it.
+            if (p != NULL) {
+                p->down = k;
+                p->up = next;
+            }
+            return true;
+        }
+        next = next->next;
+    }
+    // didn't find it.
+    return false;
+}
+
+// given a QK_MOD_TAP keycode, return the KC_* version of the modifier keycode.
+uint16_t get_mod_kc(uint16_t keycode) {
+    uint8_t mod = mod_config((keycode >> 0x8) & 0x1F);
+    switch (mod) {
+    case MOD_LCTL:
+        return KC_LCTL;
+    case MOD_RCTL:
+        return KC_RCTL;
+    case MOD_LSFT:
+        return KC_LSFT;
+    case MOD_RSFT:
+        return KC_RSFT;
+    case MOD_LALT:
+        return KC_LALT;
+    case MOD_RALT:
+        return KC_RALT;
+    case MOD_LGUI:
+        return KC_LGUI;
+    case MOD_RGUI:
+        return KC_RGUI;
+    default:
+        // shrug?  this shouldn't happen.
+        return keycode;
+    }
+}
+
+bool is_mod_kc(uint16_t keycode) {
+    switch (keycode) {
+    case QK_MODS ... QK_MODS_MAX:
+        return true;
+    default:
+        return false;
+    }
+}
+
+void interpret_as_mod(pending_pair_t *p) {
+    // see https://github.com/qmk/qmk_firmware/issues/1503
+    pending_key_t *k;
+    k = p->down;
+    if (k != NULL) {
+        k->keycode = get_mod_kc(k->keycode);
+    }
+    k = p->up;
+    if (k != NULL) {
+        k->keycode = get_mod_kc(k->keycode);
+    }
+}
+
+void interpret_as_normal(pending_pair_t *p) {
+    pending_key_t *k;
+    k = p->down;
+    if (k != NULL) {
+        k->keycode = k->keycode & 0xFF;
+    }
+    k = p->up;
+    if (k != NULL) {
+        k->keycode = k->keycode & 0xFF;
+    }
+}
+
+void execute_head_and_pop(kring_t *ring) {
+    pending_key_t *head = kring_get(ring, 0);
+    uint16_t kc = head->keycode;
+    if (is_mod_kc(kc)) {
+        if (is_down(head)) {
+            dprintf("  %s: mod down 0x%04X\n", __func__, kc);
+            set_mods(get_mods() | MOD_BIT(kc));
+        } else {
+            dprintf("  %s: mod up 0x%04X\n", __func__, kc);
+            set_mods(get_mods() & ~MOD_BIT(kc));
+        }
+    } else {
+        if (is_down(head)) {
+            dprintf("  %s: key down 0x%04X\n", __func__, kc);
+            register_code16(kc);
+        } else {
+            dprintf("  %s: key up 0x%04X\n", __func__, kc);
+            unregister_code16(kc);
+        }
+    }
+    kring_pop(ring);
+}
+
+// try to figure out what the next pending keypress means.
+bool parse_next(kring_t *pending) {
+    pending_pair_t p;
+    pending_key_t *first = kring_get(pending, 0);
+    if (!is_ambiguous_kc(first->keycode)) {
+        // this pending key isn't ambiguous, so execute it.
+        dprintf(" %s: found unambiguous key\n", __func__);
+        execute_head_and_pop(pending);
+        return true;
+    } else if (is_ambiguous_kc(first->keycode) && is_up(first)) {
+        dprintf(" %s: interpreting keyup as mod\n", __func__);
+        p.down = NULL;
+        p.up = first;
+        interpret_as_mod(&p);
+        execute_head_and_pop(pending);
+        return true;
+    } else if (is_downup_pair(first, &p)) {
+        // 'first' was released before any other pressed key, so treat this as
+        // a rolling series of normal key taps.
+        dprintf(" %s: found down-up pair, interpreting as normal key\n", __func__);
+        interpret_as_normal(&p);
+        execute_head_and_pop(pending);
+        return true;
+    } else {
+        // if another key was pressed and released while 'first' was held, then we
+        // should treat it like a modifier.
+        pending_key_t *next = first->next;
+        while (next != NULL) {
+            if (is_downup_pair(next, NULL)) {
+                dprintf(" %s: found subsequent downup pair, interpreting head as mod\n", __func__);
+                p.down = first;
+                p.up = NULL;
+                interpret_as_mod(&p);
+                execute_head_and_pop(pending);
+                return true;
+            }
+            next = next->next;
+        }
+
+        // we can't disambiguate 'first' yet.  wait for another keypress.
+        dprintf(" %s: can't disambiguate (yet)\n", __func__);
+        return false;
+    }
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+    if (keycode == DEBUG) {
+        return true;
+    }
+
+    if (g_pending.count == 0 && !is_ambiguous_kc(keycode)) {
+        // we have no pending keys and this key isn't ambiguous, so we should
+        // just let QMK take care of it.
+        dprintf("%s: handled by qmk\n", __func__);
+        return true;
+    } else {
+        dprintf("%s: got dual-role key\n", __func__);
+        // append the keypress and then try parsing all pending keypresses.
+        kring_append(&g_pending, keycode, record);
+        while (g_pending.count > 0) {
+            dprintf("%s: looping through %d keys...\n", __func__, g_pending.count);
+            if (!parse_next(&g_pending)) {
+                // one of our keypresses is ambiguous and we can't proceed until
+                // we get further keypresses to disambiguate it.
+                dprintf("%s: %d pending keys are ambiguous\n", __func__, g_pending.count);
+                break;
+            }
+        }
+        return false;
+    }
+}

keyboards/handwired/hexon38/readme.md

@@ -0,0 +1,11 @@
+# hexon38
+
+QMK support for the [hexon38](https://github.com/pepaslabs/hexon38).
+
+## Building
+
+```
+$ cd qmk_firmware
+$ make handwired/hexon38
+```
+

keyboards/handwired/hexon38/rules.mk

@@ -0,0 +1,64 @@
+# see https://github.com/pepaslabs/hexon38
+
+# MCU name
+MCU = atmega32u4
+
+# Processor frequency.
+#     This will define a symbol, F_CPU, in all source code files equal to the
+#     processor frequency in Hz. You can then use this symbol in your source code to
+#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#     automatically to create a 32-bit value in your source code.
+#
+#     This will be an integer division of F_USB below, as it is sourced by
+#     F_USB after it has run through any CPU prescalers. Note that this value
+#     does not *change* the processor frequency - it should merely be updated to
+#     reflect the processor speed set externally so that the code can use accurate
+#     software delays.
+F_CPU = 16000000
+
+#
+# LUFA specific
+#
+# Target architecture (see library "Board Types" documentation).
+ARCH = AVR8
+
+# Input clock frequency.
+#     This will define a symbol, F_USB, in all source code files equal to the
+#     input clock frequency (before any prescaling is performed) in Hz. This value may
+#     differ from F_CPU if prescaling is used on the latter, and is required as the
+#     raw input clock is fed directly to the PLL sections of the AVR for high speed
+#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
+#     at the end, this will be done automatically to create a 32-bit value in your
+#     source code.
+#
+#     If no clock division is performed on the input clock inside the AVR (via the
+#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
+F_USB = $(F_CPU)
+
+# Interrupt driven control endpoint task(+60)
+OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+
+
+# Bootloader selection
+#   Teensy       halfkay
+#   Pro Micro    caterina
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   atmega32a    bootloadHID
+BOOTLOADER = halfkay
+
+
+# Enabled build options:
+BOOTMAGIC_ENABLE = yes	# Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE = yes	# Mouse keys(+4700)
+EXTRAKEY_ENABLE = yes	# Audio control and System control(+450)
+CONSOLE_ENABLE = yes	# Console for debug(+400)
+COMMAND_ENABLE = yes    # Commands for debug and configuration
+NKRO_ENABLE = yes		# USB Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+
+# Disabled build options:
+SLEEP_LED_ENABLE = no  # Breathing sleep LED during USB suspend
+BACKLIGHT_ENABLE = no  # Enable keyboard backlight functionality
+AUDIO_ENABLE = no
+RGBLIGHT_ENABLE = no

keyboards/iris/keymaps/omgvee/readme.md

@@ -4,6 +4,10 @@
 
 ![My beloved IRIS keeb](https://i.imgur.com/wgsb37e.jpg)
 
+![My beloved choc IRIS keeb](https://imgur.com/a/NDXqLGb)
+=======
+
+
 - mouse keys
 - media keys and media controls
 - in-switch LED intensity controls (+/-)
@@ -14,4 +18,6 @@
 - also have alternates on the same layer, in the form of AWSD, as well as HJKL (keep in mind the order is Left, Up, Down, Right)
 - arrow keys on one layer, however with another modifier key, they become left=home, right=end, up=page up, down=page Down
 
-See keymap.c for layouts
+
+See keymap.c for layouts
+

keyboards/minidox/keymaps/tw1t611/keymap.c

@@ -0,0 +1,59 @@
+#include QMK_KEYBOARD_H
+#include "keymap_german.h"
+
+extern keymap_config_t keymap_config;
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+#define _QWERTZ 0
+#define _LOWER 1
+#define _RAISE 2
+#define _ADJUST 3
+
+enum custom_keycodes {
+  QWERTY = SAFE_RANGE,
+  LOWER,
+  RAISE,
+  ADJUST,
+};
+
+// macro keys
+#define CALTDEL LCTL(LALT(KC_DEL)) // ctrl-alt-del
+#define CALTESC LCTL(LSFT(KC_ESC)) // ctrl-alt-esc
+#define CALT LCTL(KC_LALT) // ctrl-alt
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+[_QWERTZ] = LAYOUT( \
+  DE_Q,    DE_W,    DE_E,    DE_R,    DE_T,                       DE_Z,    DE_U,    DE_I,    DE_O,    DE_P, \
+  DE_A,    DE_S,    DE_D,    DE_F,    DE_G,                       DE_H,    DE_J,    DE_K,    DE_L,    KC_SPC,  \
+  DE_Y,    DE_X,    DE_C,    DE_V,    DE_B,                       DE_N,    DE_M,    DE_COMM, DE_DOT,  DE_MINS,  \
+                     KC_LCTRL, MO(_LOWER), MO(_RAISE),		      KC_LGUI, KC_LSFT, KC_LALT \
+),
+
+[_RAISE] = LAYOUT( \
+  DE_EXLM,  DE_QST,   DE_PARA, DE_DLR,  DE_HASH,                  DE_PLUS,  DE_7,  DE_8,   DE_9, DE_0,  \
+  DE_CIRC,  DE_QUOT, DE_DQOT, DE_GRV, DE_AMPR,              	    DE_ASTR,  DE_4,  DE_5,   DE_6, DE_EQL, \
+  DE_SLSH,  DE_PIPE,  DE_BSLS, DE_AT,   DE_EURO,                  DE_PERC,  DE_1,  DE_2,   DE_3, KC_TAB,  \
+                    _______, _______, _______,        _______,  _______,  _______ \
+),
+
+[_LOWER] = LAYOUT( \
+  KC_AUDIO_MUTE,  KC_AUDIO_VOL_DOWN,  DE_LBRC,  DE_RBRC,  KC_AUDIO_VOL_UP,  KC_HOME,      KC_PGDOWN,  KC_PGUP,  KC_END,   DE_TILD,  \
+  KC_ESC,   DE_LESS,  DE_LPRN,  DE_RPRN,  DE_MORE,                          KC_LEFT,      KC_DOWN,    KC_UP,    KC_RIGHT, KC_ENT,  \
+  KC_BSPC,  KC_DEL,   DE_LCBR,  DE_RCBR,  KC_PSCR,                        	_______,  DE_AE,    DE_OE,    DE_UE,    DE_SS,  \
+                        _______, _______, _______,                    _______,  MO(_ADJUST), _______  \
+),
+
+[_ADJUST] = LAYOUT( \
+  _______,  _______,  _______,  _______,  _______,             _______,   KC_F7,    KC_F8,    KC_F9,   KC_F10,  \
+  CALTESC,  CALTDEL,  _______,  CALT,     _______,             _______,   KC_F4,    KC_F5,    KC_F6,   KC_F11,  \
+  RESET,    _______,  _______,  _______,  _______,             _______,   KC_F1,     KC_F2,    KC_F3,   KC_F12,  \
+                          _______,  _______,  _______,      _______,  _______,  _______  \
+)};
+
+void matrix_init_user(void) {
+  set_single_persistent_default_layer(_QWERTZ);
+};

keyboards/minidox/keymaps/tw1t611/readme.md

@@ -0,0 +1,23 @@
+# Minidox Layout by tw1t611
+![](https://imgur.com/M95KSke.png)
+
+This is a german layout with support for umlauts and the euro sign.
+You need to set your system layout to german.
+
+[keyboard-layout-editor.com](http://www.keyboard-layout-editor.com/#/gists/d58a82d8017d0c0cca044ef385def165)
+
+## Layers
+| Layer | Legend |
+| ----- | ------ |
+| Base  | Top left (white) |
+| Lower | Top right (organge) |
+| Raise | Bottom right (blue) |
+| Adjust | Front print (orange + shift) |
+
+## Features
+* German layout with support for umlauts and the euro sign
+* Raise/lower layers focus first on one-handed use
+* Numpad on right hand with raise layer
+* Vim optimized
+    * Easy reachable Esc
+    * arrow keys on h, j, k, l

keyboards/minidox/keymaps/tw1t611/rules.mk

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

keyboards/niu_mini/keymaps/spacebarracecar/keymap.c

@@ -28,7 +28,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   KC_TAB,   DE_Q,     DE_W,     DE_E,     DE_R,     DE_T,     CU_Z,     DE_U,     DE_I,     DE_O,     DE_P,     KC_BSPC,
   CU_NAV,   DE_A,     DE_S,     DE_D,     DE_F,     DE_G,     DE_H,     DE_J,     DE_K,     DE_L,     CU_SCLN,  CU_QUOT,
   CU_LSFT,  CU_Y,     DE_X,     DE_C,     DE_V,     DE_B,     DE_N,     DE_M,     CU_COMM,  CU_DOT,   CU_SLSH,  CU_RSFT,
-  KC_LCTL,  XXXXXXX,  KC_LGUI,  KC_LALT,  LOWER,    KC_SPC,   KC_ENT,   RAISE,    KC_RALT,  KC_RGUI,  KC_APP,   KC_RCTL
+  KC_LCTL,  XXXXXXX,  KC_LGUI,  KC_LALT,  LOWER,    KC_SPC,   CTLENT,   RAISE,    KC_RALT,  KC_RGUI,  KC_APP,   KC_RCTL
 ),
 
 /* Lower
@@ -103,7 +103,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   ALTF4,    KC_PGDN,  KC_UP,    KC_PGUP,  KC_HOME,  XXXXXXX,  XXXXXXX,  XXXXXXX,  GUIU,     XXXXXXX,  XXXXXXX,  KC_DEL,
   _______,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_END,   XXXXXXX,  XXXXXXX,  GUIL,     GUID,     GUIR,     RGB_M_P,  KC_ENT,
   _______,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_VOLD,  KC_VOLU,  KC_MUTE,  RGB_TOG,  RGB_MOD,  RGB_HUI,  CU_RGBV,  _______,
-  RESET,    CU_ESCT,  _______,  _______,  _______,  KC_SPC,   KC_ENT,   _______,  _______,  _______,  _______,  CU_GAME
+  RESET,    CU_ESCT,  _______,  _______,  _______,  KC_SPC,   CTLENT,   _______,  _______,  _______,  _______,  CU_GAME
 )
 
 };

keyboards/planck/keymaps/spacebarracecar/keymap.c

@@ -29,7 +29,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   KC_TAB,   DE_Q,     DE_W,     DE_E,     DE_R,     DE_T,     CU_Z,     DE_U,     DE_I,     DE_O,     DE_P,     KC_BSPC,
   CU_NAV,   DE_A,     DE_S,     DE_D,     DE_F,     DE_G,     DE_H,     DE_J,     DE_K,     DE_L,     CU_SCLN,  CU_QUOT,
   CU_LSFT,  CU_Y,     DE_X,     DE_C,     DE_V,     DE_B,     DE_N,     DE_M,     CU_COMM,  CU_DOT,   CU_SLSH,  CU_RSFT,
-  KC_LCTL,  XXXXXXX,  KC_LGUI,  KC_LALT,  LOWER,    KC_SPC,   KC_ENT,   RAISE,    KC_RALT,  KC_RGUI,  KC_APP,   KC_RCTL
+  KC_LCTL,  XXXXXXX,  KC_LGUI,  KC_LALT,  LOWER,    KC_SPC,   CTLENT,   RAISE,    KC_RALT,  KC_RGUI,  KC_APP,   KC_RCTL
 ),
 
 /* Lower
@@ -111,7 +111,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   ALTF4,    KC_PGDN,  KC_UP,    KC_PGUP,  KC_HOME,  XXXXXXX,  XXXXXXX,  XXXXXXX,  GUIU,     XXXXXXX,  XXXXXXX,  KC_DEL,
   _______,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_END,   XXXXXXX,  XXXXXXX,  GUIL,     GUID,     GUIR,     XXXXXXX,  KC_ENT,
   _______,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_VOLD,  KC_VOLU,  KC_MUTE,  MU_ON,    XXXXXXX,  XXXXXXX,  XXXXXXX,  _______,
-  RESET,    CU_ESCT,  _______,  _______,  _______,  KC_SPC,   KC_ENT,   _______,  _______,  _______,  _______,  CU_GAME
+  RESET,    CU_ESCT,  _______,  _______,  _______,  KC_SPC,   CTLENT,   _______,  _______,  _______,  _______,  CU_GAME
 )
 
 };

keyboards/primekb/prime_o/keymaps/spacebarracecar/keymap.c

@@ -25,9 +25,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 |---------+---------+---------+---------|---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
 |=        |4        |5        |6        |Esc/Nav  |A        |S        |D        |F        |G        |H        |J        |K        |L        |;        |'        |
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|Enter    |1        |2        |3        |(/LShift |Y        |X        |C        |V        |B        |N        |M        |,        |.        |/        |)/RShift |
+|Backspace|1        |2        |3        |(/LShift |Y        |X        |C        |V        |B        |N        |M        |,        |.        |/        |)/RShift |
 |---------+---------+---------+---------|---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|Backspace|.        |0        |00       |RCtrl    |         |Alt      |Win      |Lower    |Space    |Enter    |Raise    |Win      |AltGr    |         |LCtrl    |
+|Enter    |.        |0        |00       |RCtrl    |         |Alt      |Win      |Lower    |Space    |Enter    |Raise    |Win      |AltGr    |         |LCtrl    |
 `---------------------------------------------------------------------------------------------------------------------------------------------------------------'
 */
 
@@ -35,8 +35,8 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   KC_PMNS,  KC_PAST,  KC_PSLS,  KC_NLCK,  CU_GRV,   DE_1,     DE_2,     CU_3,     DE_4,     DE_5,     CU_6,     CU_7,     CU_8,     CU_9,     CU_0,     CU_BSLS,
   KC_PPLS,  KC_P7,    KC_P8,    KC_P9,    KC_TAB,   DE_Q,     DE_W,     DE_E,     DE_R,     DE_T,     CU_Z,     DE_U,     DE_I,     DE_O,     DE_P,     KC_BSPC,
   CU_EQL,   KC_P4,    KC_P5,    KC_P6,    CU_NAV,   DE_A,     DE_S,     DE_D,     DE_F,     DE_G,     DE_H,     DE_J,     DE_K,     DE_L,     CU_SCLN,  CU_QUOT,
-  KC_PENT,  KC_P1,    KC_P2,    KC_P3,    CU_LSFT,  CU_Y,     DE_X,     DE_C,     DE_V,     DE_B,     DE_N,     DE_M,     CU_COMM,  CU_DOT,   CU_SLSH,  CU_RSFT,
+  KC_BSPC,  KC_P1,    KC_P2,    KC_P3,    CU_LSFT,  CU_Y,     DE_X,     DE_C,     DE_V,     DE_B,     DE_N,     DE_M,     CU_COMM,  CU_DOT,   CU_SLSH,  CU_RSFT,
-  KC_BSPC,  KC_PDOT,  KC_P0,    KC_P00,   KC_LCTL,  XXXXXXX,  KC_LGUI,  KC_LALT,  LOWER,    KC_SPC,   KC_ENT,   RAISE,    KC_RALT,  KC_RGUI,  KC_APP,   KC_RCTL
+  KC_PENT,  KC_PDOT,  KC_P0,    KC_P00,   KC_LCTL,  XXXXXXX,  KC_LGUI,  KC_LALT,  LOWER,    KC_SPC,   CTLENT,   RAISE,    KC_RALT,  KC_RGUI,  KC_APP,   KC_RCTL
 ),
 
 /* Lower
@@ -47,9 +47,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 |---------+---------+---------+---------|---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
 |=        |4        |5        |6        |         |@        |Strg+X   |Strg+C   |Strg+V   |         |         |_        |+        |{        |}        ||        |
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|Enter    |1        |2        |3        |         |?        |         |         |         |         |         |         |         |         |         |         |
+|Backspace|1        |2        |3        |         |?        |         |         |         |         |         |         |         |         |         |         |
 |---------+---------+---------+---------|---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|Backspace|.        |0        |00       |         |         |         |         |         |         |         |         |         |         |         |         |
+|Enter    |.        |0        |00       |         |         |         |         |         |         |         |         |         |         |         |         |
 `---------------------------------------------------------------------------------------------------------------------------------------------------------------'
 */
 
@@ -69,9 +69,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 |---------+---------+---------+---------|---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
 |=        |4        |5        |6        |         |F1       |F2       |F3       |F4       |F5       |F6       |-        |=        |[        |]        |\        |
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|Enter    |1        |2        |3        |         |F7       |F8       |F9       |F10      |F11      |F12      |         |         |         |         |         |
+|Backspace|1        |2        |3        |         |F7       |F8       |F9       |F10      |F11      |F12      |         |         |         |         |         |
 |---------+---------+---------+---------|---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|Backspace|.        |0        |00       |         |         |         |         |         |         |         |         |         |         |         |         |
+|Enter    |.        |0        |00       |         |         |         |         |         |         |         |         |         |         |         |         |
 `---------------------------------------------------------------------------------------------------------------------------------------------------------------'
 */
 
@@ -91,9 +91,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 |---------+---------+---------+---------|---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
 |=        |4        |5        |6        |         |Ä        |ß        |         |         |         |         |         |         |         |         |         |
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|Enter    |1        |2        |3        |         |         |         |         |         |         |         |         |         |         |         |         |
+|Backspace|1        |2        |3        |         |         |         |         |         |         |         |         |         |         |         |         |
 |---------+---------+---------+---------|---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|Backspace|.        |0        |00       |         |         |         |         |         |"        |"        |         |         |         |         |         |
+|Enter    |.        |0        |00       |         |         |         |         |         |"        |"        |         |         |         |         |         |
 `---------------------------------------------------------------------------------------------------------------------------------------------------------------'
 */
 
@@ -113,9 +113,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 |---------+---------+---------+---------|---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
 |=        |4        |5        |6        |         |Left     |Down     |Right    |End      |         |         |Win+Left |Win+Down |Win+Right|         |Enter    |
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|Enter    |1        |2        |3        |         |Prev     |Pause    |Next     |LowerVol |RaiseVol |Mute     |         |         |         |         |         |
+|Backspace|1        |2        |3        |         |Prev     |Pause    |Next     |LowerVol |RaiseVol |Mute     |         |         |         |         |         |
 |---------+---------+---------+---------|---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|Backspace|.        |0        |00       |RESET    |ESCT     |         |         |         |         |         |         |         |         |         |Game     |
+|Enter    |.        |0        |00       |RESET    |ESCT     |         |         |         |         |         |         |         |         |         |Game     |
 `---------------------------------------------------------------------------------------------------------------------------------------------------------------'
 */
 
@@ -124,7 +124,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   _______,  _______,  _______,  _______,  ALTF4,    KC_PGDN,  KC_UP,    KC_PGUP,  KC_HOME,  XXXXXXX,  XXXXXXX,  XXXXXXX,  GUIU,     XXXXXXX,  XXXXXXX,  KC_DEL,
   _______,  _______,  _______,  _______,  _______,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_END,   XXXXXXX,  XXXXXXX,  GUIL,     GUID,     GUIR,     XXXXXXX,  KC_ENT,
   _______,  _______,  _______,  _______,  _______,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_VOLD,  KC_VOLU,  KC_MUTE,  XXXXXXX,  XXXXXXX,  XXXXXXX,  XXXXXXX,  _______,
-  _______,  _______,  _______,  _______,  RESET,    CU_ESCT,  _______,  _______,  _______,  KC_SPC,   KC_ENT,   _______,  _______,  _______,  _______,  CU_GAME
+  _______,  _______,  _______,  _______,  RESET,    CU_ESCT,  _______,  _______,  _______,  KC_SPC,   CTLENT,   _______,  _______,  _______,  _______,  CU_GAME
 ),
 
 // Can be used to place macros on the numpad
@@ -146,9 +146,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
 |Esc/Nav  |A        |S        |D        |F        |G        |4        |5        |6        |+        |H        |J        |K        |L        |;        |'        |
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|(/LShift |Y        |X        |C        |V        |B        |1        |2        |3        |Enter    |N        |M        |,        |.        |/        |)/RShift |
+|(/LShift |Y        |X        |C        |V        |B        |1        |2        |3        |Tab      |N        |M        |,        |.        |/        |)/RShift |
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|RCtrl    |         |Alt      |Win      |Lower    |Space    |00       |0        |.        |Tab      |Enter    |Raise    |Win      |AltGr    |         |LCtrl    |
+|RCtrl    |         |Alt      |Win      |Lower    |Space    |00       |0        |.        |Enter    |Enter    |Raise    |Win      |AltGr    |         |LCtrl    |
 `---------------------------------------------------------------------------------------------------------------------------------------------------------------'
 */
 
@@ -156,8 +156,8 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   CU_GRV,   DE_1,     DE_2,     CU_3,     DE_4,     DE_5,     KC_NLCK,  KC_PSLS,  KC_PAST,  KC_PMNS,  CU_6,     CU_7,     CU_8,     CU_9,     CU_0,     CU_BSLS,
   KC_TAB,   DE_Q,     DE_W,     DE_E,     DE_R,     DE_T,     KC_P7,    KC_P8,    KC_P9,    KC_PPLS,  CU_Z,     DE_U,     DE_I,     DE_O,     DE_P,     KC_BSPC,
   CU_NAV,   DE_A,     DE_S,     DE_D,     DE_F,     DE_G,     KC_P4,    KC_P5,    KC_P6,    CU_EQL,   DE_H,     DE_J,     DE_K,     DE_L,     CU_SCLN,  CU_QUOT,
-  CU_LSFT,  CU_Y,     DE_X,     DE_C,     DE_V,     DE_B,     KC_P1,    KC_P2,    KC_P3,    KC_PENT,  DE_N,     DE_M,     CU_COMM,  CU_DOT,   CU_SLSH,  CU_RSFT,
+  CU_LSFT,  CU_Y,     DE_X,     DE_C,     DE_V,     DE_B,     KC_P1,    KC_P2,    KC_P3,    KC_TAB,   DE_N,     DE_M,     CU_COMM,  CU_DOT,   CU_SLSH,  CU_RSFT,
-  KC_LCTL,  XXXXXXX,  KC_LGUI,  KC_LALT,  LOWER,    KC_SPC,   KC_P00,   KC_P0,    KC_PDOT,  KC_TAB,   KC_ENT,   RAISE,    KC_RALT,  KC_RGUI,  KC_APP,   KC_RCTL
+  KC_LCTL,  XXXXXXX,  KC_LGUI,  KC_LALT,  LOWER,    KC_SPC,   KC_P00,   KC_P0,    KC_PDOT,  KC_PENT,  CTLENT,   RAISE,    KC_RALT,  KC_RGUI,  KC_APP,   KC_RCTL
 ),
 
 /* Lower
@@ -168,9 +168,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
 |         |@        |Strg+X   |Strg+C   |Strg+V   |         |4        |5        |6        |=        |         |_        |+        |{        |}        ||        |
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|         |?        |         |         |         |         |1        |2        |3        |Enter    |         |         |         |         |         |         |
+|         |?        |         |         |         |         |1        |2        |3        |Tab      |         |         |         |         |         |         |
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|         |         |         |         |         |         |00       |0        |.        |Tab      |         |         |         |         |         |         |
+|         |         |         |         |         |         |00       |0        |.        |Enter    |         |         |         |         |         |         |
 `---------------------------------------------------------------------------------------------------------------------------------------------------------------'
 */
 
@@ -190,9 +190,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
 |         |F1       |F2       |F3       |F4       |F5       |4        |5        |6        |=        |F6       |-        |=        |[        |]        |\        |
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|         |F7       |F8       |F9       |F10      |F11      |1        |2        |3        |Enter    |F12      |         |         |         |         |         |
+|         |F7       |F8       |F9       |F10      |F11      |1        |2        |3        |Tab      |F12      |         |         |         |         |         |
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|         |         |         |         |         |         |00       |0        |.        |Tab      |         |         |         |         |         |         |
+|         |         |         |         |         |         |00       |0        |.        |Enter    |         |         |         |         |         |         |
 `---------------------------------------------------------------------------------------------------------------------------------------------------------------'
 */
 
@@ -212,9 +212,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
 |         |Ä        |ß        |         |         |         |4        |5        |6        |=        |         |         |         |         |         |         |
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|         |         |         |         |         |         |1        |2        |3        |Enter    |         |         |         |         |         |         |
+|         |         |         |         |         |         |1        |2        |3        |Tab      |         |         |         |         |         |         |
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|         |         |         |         |         |"        |00       |0        |.        |Tab      |"        |         |         |         |         |         |
+|         |         |         |         |         |"        |00       |0        |.        |Enter    |"        |         |         |         |         |         |
 `---------------------------------------------------------------------------------------------------------------------------------------------------------------'
 */
 
@@ -234,9 +234,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
 |         |Left     |Down     |Right    |End      |         |4        |5        |6        |=        |         |Win+Left |Win+Down |Win+Right|         |Enter    |
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|         |Prev     |Pause    |Next     |LowerVol |RaiseVol |1        |2        |3        |Enter    |Mute     |         |         |         |         |         |
+|         |Prev     |Pause    |Next     |LowerVol |RaiseVol |1        |2        |3        |Tab      |Mute     |         |         |         |         |         |
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|RESET    |ESCT     |         |         |         |         |00       |0        |.        |Tab      |         |         |         |         |         |Game     |
+|RESET    |ESCT     |         |         |         |         |00       |0        |.        |Enter    |         |         |         |         |         |Game     |
 `---------------------------------------------------------------------------------------------------------------------------------------------------------------'
 */
 
@@ -245,7 +245,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   ALTF4,    KC_PGDN,  KC_UP,    KC_PGUP,  KC_HOME,  XXXXXXX,  _______,  _______,  _______,  _______,  XXXXXXX,  XXXXXXX,  GUIU,     XXXXXXX,  XXXXXXX,  KC_DEL,
   _______,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_END,   XXXXXXX,  _______,  _______,  _______,  _______,  XXXXXXX,  GUIL,     GUID,     GUIR,     XXXXXXX,  KC_ENT,
   _______,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_VOLD,  KC_VOLU,  _______,  _______,  _______,  _______,  KC_MUTE,  XXXXXXX,  XXXXXXX,  XXXXXXX,  XXXXXXX,  _______,
-  RESET,    CU_ESCT,  _______,  _______,  _______,  KC_SPC,   _______,  _______,  _______,  _______,  KC_ENT,   _______,  _______,  _______,  _______,  CU_GAME
+  RESET,    CU_ESCT,  _______,  _______,  _______,  KC_SPC,   _______,  _______,  _______,  _______,  CTLENT,   _______,  _______,  _______,  _______,  CU_GAME
 ),
 
 // Can be used to place macros on the numpad
@@ -267,9 +267,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
 |Esc/Nav  |A        |S        |D        |F        |G        |H        |J        |K        |L        |;        |'        |4        |5        |6        |+        |
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|(/LShift |Y        |X        |C        |V        |B        |N        |M        |,        |.        |/        |)/RShift |1        |2        |3        |Enter    |
+|(/LShift |Y        |X        |C        |V        |B        |N        |M        |,        |.        |/        |)/RShift |1        |2        |3        |Tab      |
-|---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
+|---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+
-|RCtrl    |         |Alt      |Win      |Lower    |Space    |Enter    |Raise    |Win      |AltGr    |         |LCtrl    |00       |0        |.        |Tab      |
+|RCtrl    |         |Alt      |Win      |Lower    |Space    |Enter    |Raise    |Win      |AltGr    |         |LCtrl    |00       |0        |.        |Enter    |
 `---------------------------------------------------------------------------------------------------------------------------------------------------------------'
 */
 
@@ -277,8 +277,8 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   CU_GRV,   DE_1,     DE_2,     CU_3,     DE_4,     DE_5,     CU_6,     CU_7,     CU_8,     CU_9,     CU_0,     CU_BSLS,  KC_NLCK,  KC_PSLS,  KC_PAST,  KC_PMNS,
   KC_TAB,   DE_Q,     DE_W,     DE_E,     DE_R,     DE_T,     CU_Z,     DE_U,     DE_I,     DE_O,     DE_P,     KC_BSPC,  KC_P7,    KC_P8,    KC_P9,    KC_PPLS,
   CU_NAV,   DE_A,     DE_S,     DE_D,     DE_F,     DE_G,     DE_H,     DE_J,     DE_K,     DE_L,     CU_SCLN,  CU_QUOT,  KC_P4,    KC_P5,    KC_P6,    CU_EQL,
-  CU_LSFT,  CU_Y,     DE_X,     DE_C,     DE_V,     DE_B,     DE_N,     DE_M,     CU_COMM,  CU_DOT,   CU_SLSH,  CU_RSFT,  KC_P1,    KC_P2,    KC_P3,    KC_PENT,
+  CU_LSFT,  CU_Y,     DE_X,     DE_C,     DE_V,     DE_B,     DE_N,     DE_M,     CU_COMM,  CU_DOT,   CU_SLSH,  CU_RSFT,  KC_P1,    KC_P2,    KC_P3,    KC_TAB,
-  KC_LCTL,  XXXXXXX,  KC_LGUI,  KC_LALT,  LOWER,    KC_SPC,   KC_ENT,   RAISE,    KC_RALT,  KC_RGUI,  KC_APP,   KC_RCTL,  KC_P00,   KC_P0,    KC_PDOT,  KC_TAB
+  KC_LCTL,  XXXXXXX,  KC_LGUI,  KC_LALT,  LOWER,    KC_SPC,   CTLENT,   RAISE,    KC_RALT,  KC_RGUI,  KC_APP,   KC_RCTL,  KC_P00,   KC_P0,    KC_PDOT,  KC_PENT
 ),
 
 /* Lower
@@ -289,9 +289,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
 |         |@        |Strg+X   |Strg+C   |Strg+V   |         |         |_        |+        |{        |}        ||        |4        |5        |6        |=        |
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|         |?        |         |         |         |         |         |         |         |         |         |         |1        |2        |3        |Enter    |
+|         |?        |         |         |         |         |         |         |         |         |         |         |1        |2        |3        |Tab      |
-|---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
+|---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+
-|         |         |         |         |         |         |         |         |         |         |         |         |00       |0        |.        |Tab      |
+|         |         |         |         |         |         |         |         |         |         |         |         |00       |0        |.        |Enter    |
 `---------------------------------------------------------------------------------------------------------------------------------------------------------------'
 */
 
@@ -311,9 +311,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
 |         |F1       |F2       |F3       |F4       |F5       |F6       |-        |=        |[        |]        |\        |4        |5        |6        |=        |
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|         |F7       |F8       |F9       |F10      |F11      |F12      |         |         |         |         |         |1        |2        |3        |Enter    |
+|         |F7       |F8       |F9       |F10      |F11      |F12      |         |         |         |         |         |1        |2        |3        |Tab      |
-|---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
+|---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+
-|         |         |         |         |         |         |         |         |         |         |         |         |00       |0        |.        |Tab      |
+|         |         |         |         |         |         |         |         |         |         |         |         |00       |0        |.        |Enter    |
 `---------------------------------------------------------------------------------------------------------------------------------------------------------------'
 */
 
@@ -333,9 +333,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
 |         |Ä        |ß        |         |         |         |         |         |         |         |         |         |4        |5        |6        |=        |
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|         |         |         |         |         |         |         |         |         |         |         |         |1        |2        |3        |Enter    |
+|         |         |         |         |         |         |         |         |         |         |         |         |1        |2        |3        |Tab      |
-|---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
+|---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+
-|         |         |         |         |         |"        |"        |         |         |         |         |         |00       |0        |.        |Tab      |
+|         |         |         |         |         |"        |"        |         |         |         |         |         |00       |0        |.        |Enter    |
 `---------------------------------------------------------------------------------------------------------------------------------------------------------------'
 */
 
@@ -355,9 +355,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
 |         |Left     |Down     |Right    |End      |         |         |Win+Left |Win+Down |Win+Right|         |Enter    |4        |5        |6        |=        |
 |---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
-|         |Prev     |Pause    |Next     |LowerVol |RaiseVol |Mute     |         |         |         |         |         |1        |2        |3        |Enter    |
+|         |Prev     |Pause    |Next     |LowerVol |RaiseVol |Mute     |         |         |         |         |         |1        |2        |3        |Tab      |
-|---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------|
+|---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+---------+
-|RESET    |ESCT     |         |         |         |         |         |         |         |         |         |Game     |00       |0        |.        |Tab      |
+|RESET    |ESCT     |         |         |         |         |         |         |         |         |         |Game     |00       |0        |.        |Enter    |
 `---------------------------------------------------------------------------------------------------------------------------------------------------------------'
 */
 
@@ -366,7 +366,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   ALTF4,    KC_PGDN,  KC_UP,    KC_PGUP,  KC_HOME,  XXXXXXX,  XXXXXXX,  XXXXXXX,  GUIU,     XXXXXXX,  XXXXXXX,  KC_DEL,   _______,  _______,  _______,  _______,
   _______,  KC_LEFT,  KC_DOWN,  KC_RGHT,  KC_END,   XXXXXXX,  XXXXXXX,  GUIL,     GUID,     GUIR,     XXXXXXX,  KC_ENT,   _______,  _______,  _______,  _______,
   _______,  KC_MPRV,  KC_MPLY,  KC_MNXT,  KC_VOLD,  KC_VOLU,  KC_MUTE,  XXXXXXX,  XXXXXXX,  XXXXXXX,  XXXXXXX,  _______,  _______,  _______,  _______,  _______,
-  RESET,    CU_ESCT,  _______,  _______,  _______,  KC_SPC,   KC_ENT,   _______,  _______,  _______,  _______,  CU_GAME,  _______,  _______,  _______,  _______
+  RESET,    CU_ESCT,  _______,  _______,  _______,  KC_SPC,   CTLENT,   _______,  _______,  _______,  _______,  CU_GAME,  _______,  _______,  _______,  _______
 ),
 
 // Can be used to place macros on the numpad

quantum/audio/musical_notes.h

@@ -61,7 +61,11 @@
 
 // Notes - # = Octave
 
+#ifdef __arm__
+#define NOTE_REST         1.00f
+#else
 #define NOTE_REST         0.00f
+#endif
 
 /* These notes are currently bugged
 #define NOTE_C0          16.35f

users/spacebarracecar/config.h

@@ -0,0 +1,2 @@
+#pragma once
+#define TAPPING_TERM 200

users/spacebarracecar/spacebarracecar.c

@@ -96,7 +96,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
       navesc_timer = timer_read();
       layer_on(_NAV);
     } else {
-      if (timer_elapsed(navesc_timer) < 200 && navesc) {
+      if (timer_elapsed(navesc_timer) < TAPPING_TERM && navesc) {
         register_code(KC_ESC);
         unregister_code(KC_ESC);
       }
@@ -134,7 +134,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
       register_code(KC_LSFT);
       lshift = true;
     } else {
-      if (timer_elapsed(lshift_timer) < 200 && lshiftp && !game) {
+      if (timer_elapsed(lshift_timer) < TAPPING_TERM && lshiftp && !game) {
         register_code(KC_LSFT);
         register_code(KC_8);
         unregister_code(KC_8);
@@ -154,7 +154,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
       register_code(KC_LSFT);
       rshift = true;
     } else {
-      if (timer_elapsed(rshift_timer) < 200 && rshiftp && !game) {
+      if (timer_elapsed(rshift_timer) < TAPPING_TERM && rshiftp && !game) {
         register_code(KC_LSFT);
         register_code(KC_9);
         unregister_code(KC_9);

users/spacebarracecar/spacebarracecar.h

@@ -88,6 +88,8 @@ bool process_record_keymap(uint16_t keycode, keyrecord_t *record);
 #define GUIL LGUI(KC_LEFT)
 #define GUIR RGUI(KC_RIGHT)
 
+#define CTLENT CTL_T(KC_ENT)
+
 /*
 Templates for Keys, with custom shifted and non shifted Characters
 */