implement new features for arm

* Get audio working on clueboard/60

* add keys for music mode

* Change doubles to floats

* add keys for all the songs

* revert to the default startup sound

* Remove music mode until we can figure out why it crashes

common_features.mk

@@ -34,7 +34,11 @@ ifeq ($(strip $(AUDIO_ENABLE)), yes)
     OPT_DEFS += -DAUDIO_ENABLE
     MUSIC_ENABLE := 1
     SRC += $(QUANTUM_DIR)/process_keycode/process_audio.c
-    SRC += $(QUANTUM_DIR)/audio/audio.c
+    ifeq ($(PLATFORM),AVR)
+        SRC += $(QUANTUM_DIR)/audio/audio.c
+    else
+        SRC += $(QUANTUM_DIR)/audio/audio_arm.c
+    endif
     SRC += $(QUANTUM_DIR)/audio/voices.c
     SRC += $(QUANTUM_DIR)/audio/luts.c
 endif

keyboards/chimera_ortho/keymaps/gordon/keymap.c

@@ -0,0 +1,389 @@
+// this is the style you want to emulate.
+// This is the canonical layout file for the Quantum project. If you want to add another keyboard,
+
+#include "chimera_ortho.h"
+#include "action_layer.h"
+#include "version.h"
+#include "process_keycode/process_tap_dance.h"
+#include "gordon.h"
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+
+#define CALTDEL LCTL(LALT(KC_DEL))
+#define TSKMGR LCTL(LSFT(KC_ESC))
+
+#define KC_SNAPLEFT LGUI(KC_LEFT)
+#define KC_SNAPRIGHT LGUI(KC_RIGHT)
+#define KC_SNAPUP LGUI(KC_UP)
+#define KC_SNAPDOWN LGUI(KC_DOWN)
+#define KC_PREVTAB LCTL(LSFT(KC_TAB))
+#define KC_NEXTTAB LCTL(KC_TAB)
+#define KC_WORKRIGHT LCTL(LGUI(KC_RIGHT))
+#define KC_WORKLEFT LCTL(LGUI(KC_LEFT))
+
+#define KC_NMPD TG(_NUMPAD)
+#define KC_SYMB TG(_SYMBOLS)
+
+#define KC_SCTL MT(MOD_LCTL, KC_LBRC)
+#define KC_SCTR MT(MOD_LCTL, KC_RBRC)
+#define KC_SPLT MT(MOD_LALT, KC_MINS)
+#define KC_SPRT MT(MOD_LALT, KC_1)
+#define KC_GBRC MT(MOD_RGUI, KC_8)
+#define KC_GQOT MT(MOD_LGUI, KC_QUOT)
+#define KC_CSHW MT(MOD_LCTL|MOD_LSFT,KC_W)
+
+#define KC_CDEL LCTL(KC_DEL)
+#define KC_AUDUP KC_AUDIO_VOL_UP
+#define KC_AUDOWN KC_AUDIO_VOL_DOWN
+
+
+#define KC_MEHS MEH_T(KC_S)
+#define KC_MEHL MEH_T(KC_L)
+#define KC_GWIN GUI_T(KC_G)
+#define KC_FCTL CTL_T(KC_F)
+#define KC_JCTL CTL_T(KC_J)
+#define KC_ZCTL CTL_T(KC_Z)
+#define KC_ALTV ALT_T(KC_V)
+#define KC_ALTN ALT_T(KC_N)
+#define KC_MEHX ALL_T(KC_X)
+#define KC_RESET RESET
+
+//LTs
+#define KC_MESC LT(_MACROS, KC_ESC)
+#define KC_DNUM LT(_NUMPAD, KC_D)
+#define KC_SPFN LT(_NAV,KC_EQL)
+#define KC_EMAUS LT(_MOUSE,KC_E)
+#define KC_ENAV LT(_NAV,KC_E)
+#define KC_INAV LT(_TEXTNAV,KC_I)
+#define KC_BSPSYM LT(_SYMBOLS,KC_BSPACE)
+#define KC_ENTSYM LT(_SYMBOLS,KC_ENTER)
+#define KC_CLNMAUS LT(_MOUSE,KC_SCOLON)
+
+#define KC_FUNC TT(_FUNCTION)
+
+//TAP DANCE
+#define KC_F6F7 TD(F6F7)
+#define KC_ALF4 TD(ALTF4)
+#define KC_TTT TD(TTT)
+#define KC_ENHM TD(HOME_END)
+#define KC_CLPS TD(CALC_PRINTSCREEN)
+
+
+#define KC_INCL M(0)
+#define KC_PULL M(1)
+#define KC_PUSH M(2)
+#define KC_SCAP M(3)
+#define KC_SCOF M(4)
+#define KC_CAD LALT(LCTL(KC_DEL))
+
+#define LONGPRESS_DELAY 150
+//#define LAYER_TOGGLE_DELAY 300
+
+// Fillers to make layering more clear
+#define _______ KC_TRNS
+#define XXXXXXX KC_NO
+#define KC_ KC_TRNS 
+
+/* TODO: 
+ *
+ * DONE: RESET and CAD into macro layer.
+ * DONE: WINUP AND WINDOWN in NAV layer
+ * DONE: Get rid of caps layer. not sure what it is even for.
+ * DONE: LMEH
+ * DONE: plus, divide, multiply on left hand for num layer
+ * DONE: F1 - F12 on a layer toggle (not a temp toggle but a one shot or something)
+ * DONE: Volume, page up and down for mouse layer.
+ * DONE: Add full user files - without using anything.
+ * DONE: Insert, ctrl delete
+ * DONE: Home and End
+ * DONE: Printscreen
+
+ * Easier way to open new terminal (instead of alt + F2)
+ * Intellij/text navigation layer (ctrl delete could be here).
+ * Macro for "System.exit(0)" probably macro layer and "c"
+ * Some sort of tap dance for comma, H, right pinky, and possibly other corners.
+ * Something more with the right hand. not sure what.
+ * Mouse: Left scroll, right scroll
+ * Passwords and any other macros.
+ * LED for control
+ * All modifiers reset
+ * Russain layer
+ * Hebrew layer
+ * Get rid of stupid git pull and push macros.
+ * 
+*/
+
+//Tap dance enums
+enum {
+  F12ETAPS = 0,
+  CALCCOMP,
+  ALTF4,
+  F6F7,
+  TTT,
+  HOME_END,
+  CALC_PRINTSCREEN
+};
+
+static xtap ttt_state = { 
+  .is_press_action = true,
+  .state = 0
+};
+
+
+//Already exists in gordon.c, shouldn't need this anymore
+/*// To activate SINGLE_HOLD, you will need to hold for 200ms first. 
+// This tap dance favors keys that are used frequently in typing like 'f'
+int cur_dance (qk_tap_dance_state_t *state) {
+  if (state->count == 1) {
+    if (state->interrupted) {
+      return SINGLE_TAP;
+    }
+    else {
+      if (!state->pressed) return SINGLE_TAP;
+      else return SINGLE_HOLD;
+    }
+  }
+  //If count = 2, and it has been interrupted - assume that user is trying to type the letter associated
+  //with single tap.
+  else if (state->count == 2) {
+    if (state->interrupted) return DOUBLE_SINGLE_TAP;
+    else if (state->pressed) return DOUBLE_HOLD;
+    else return DOUBLE_TAP; 
+  } 
+  else if ((state->count == 3) && ((state->interrupted) || (!state->pressed))) return TRIPLE_TAP;
+  else if (state->count == 3) return TRIPLE_HOLD;
+  else return 8; //magic number. At some point this method will expand to work for more presses
+}*/
+
+/* "Super tap toggle"
+ * Basically, TT but for two or more layers for a single key.
+ * This particular dance:
+ * Single tap/hold - TT for Function layer
+ * Double tap/hold - TT for Numpad layer
+ * Triple tap/hold - TT for Mouse layer
+ *
+*/
+void TTT_finished (qk_tap_dance_state_t *state, void *user_data) {
+  ttt_state.state = cur_dance(state);
+  switch (ttt_state.state) {
+    case SINGLE_TAP: layer_invert(_FUNCTION); break;
+    case SINGLE_HOLD: layer_on(_FUNCTION); break;
+    case DOUBLE_TAP: layer_invert(_NUMPAD); break;
+    case DOUBLE_HOLD: layer_on(_NUMPAD); break;
+    case DOUBLE_SINGLE_TAP: layer_invert(_NUMPAD); break;
+    case TRIPLE_TAP: layer_invert(_MOUSE); break;
+    case TRIPLE_HOLD: layer_on(_MOUSE); break;
+  }
+}
+
+void TTT_reset (qk_tap_dance_state_t *state, void *user_data) {
+  switch (ttt_state.state) {
+    case SINGLE_TAP: break;
+    case SINGLE_HOLD: layer_off(_FUNCTION); break;
+    case DOUBLE_TAP:  break;
+    case DOUBLE_HOLD: layer_off(_NUMPAD); break;
+    case DOUBLE_SINGLE_TAP:  break;
+    case TRIPLE_TAP:  break;
+    case TRIPLE_HOLD: layer_off(_MOUSE); break;
+  }
+  ttt_state.state = 0;
+}
+
+qk_tap_dance_action_t tap_dance_actions[] = {
+  // simple tap dance
+  [F12ETAPS] = ACTION_TAP_DANCE_DOUBLE(KC_F12,LSFT(LCTL(KC_F10))),  
+  [CALCCOMP] = ACTION_TAP_DANCE_DOUBLE(KC_CALCULATOR, KC_MY_COMPUTER),
+  [CALC_PRINTSCREEN] = ACTION_TAP_DANCE_DOUBLE(KC_CALCULATOR, KC_PSCR),
+  [ALTF4] = ACTION_TAP_DANCE_DOUBLE(KC_F4,LALT(KC_F4)),
+  [F6F7] = ACTION_TAP_DANCE_DOUBLE(LSFT(KC_F6), LALT(KC_F7)),
+  [HOME_END] = ACTION_TAP_DANCE_DOUBLE(KC_END, KC_HOME),
+  [TTT] = ACTION_TAP_DANCE_FN_ADVANCED(NULL,TTT_finished, TTT_reset),
+};
+
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+  [_QWERTY] = KEYMAP(
+  //,----+----+----+----+----+----+----.      ,----+----+----+----+----+----+----.
+     MESC, Q  ,CSHW,ENAV, R  , T  ,SPC ,       CLPS, Y  , U  ,INAV, O  , P  ,TTT,
+  //|----+----+----+----+----+----+----|      |----+----+----+----+----+----+----|
+     TAB , A , MEHS,DNUM,FCTL,GWIN,GRAVE,      TILD, H  ,JCTL, K ,MEHL,CLNMAUS,ENHM,
+  //|----+----+----+----+----+----+----|      |----+----+----+----+----+----+----|
+    MINUS,ZCTL,MEHX, C  ,ALTV, B  ,DELETE,     INS ,ALTN, M  ,COMM,DOT ,SLSH,UNDS,
+  //|----+----+----+----+----+----+----|      |----+----+----+----+----+----+----|
+                         LSHIFT,BSPSYM,                SPC ,ENTSYM
+  // \------------------+----+----+---/       \---+----+----+-------------------/
+  ),
+
+  [_NUMPAD] = KEYMAP(  
+  //,----+----+----+----+----+----+----.     ,----+----+----+----+----+----+----.
+         ,    ,    ,    ,ASTR,    ,    ,          ,    , 7  , 8  , 9  ,ASTR,/**/,
+  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
+         ,MINS,PLUS,/**/,EQUAL,    ,   ,          ,    , 4  , 5  , 6  ,PLUS,    ,
+  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
+         ,    ,    ,    ,SLSH,    ,    ,          ,    , 1  , 2  , 3  ,SLSH,    ,
+  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
+                             ,    ,                     , 0  
+  // \------------------+----+----+---/       \---+----+----+-------------------/
+  ),
+
+  [_SYMBOLS] = KEYMAP(  
+  //,----+----+-----+----+----+----+----.     ,----+----+----+----+----+----+----.
+         ,EXLM, AT  ,LCBR,RCBR,HASH,    ,          ,CIRC,AMPR,ASTR,LPRN,RPRN,/**/,
+  //|----+----+-----+----+----+----+----|     |----+----+----+----+----+----+----|
+         ,EXLM,EXLM,LPRN,RPRN ,    ,    ,          ,    ,DQUO,EQUAL,QUOTE,RCBR,    ,
+  //|----+----+----+----+----+----+----|      |----+----+----+----+----+----+----|
+      ,DOLLAR, PERC,LBRACKET,RBRACKET, ,      ,    ,PIPE,BSLASH,PLUS,  ,  ,  ,
+  //|----+----+-----+----+----+----+----|     |----+----+----+----+----+----+----|
+                          UNDS,/**/,                    ,/**/
+  // \-------------------+----+----+---/       \---+----+----+-------------------/
+  ),
+
+  [_FUNCTION] = KEYMAP(  
+  //,----+----+----+----+----+----+----.     ,----+----+----+----+----+----+----.
+    F6F7 ,F1  ,F2  ,F3  ,ALF4,F5  ,F6  ,      F7  ,F8  ,F9  ,F10 ,F11 ,F12 ,/**/,
+  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
+         ,    ,    ,    ,    ,    ,    ,          ,    ,    ,    ,    ,    ,    ,
+  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
+         ,    ,    ,    ,    ,    ,    ,          ,    ,    ,    ,    ,    ,    ,
+  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
+                             ,    ,                    ,    
+  // \------------------+----+----+---/       \---+----+----+-------------------/
+  ),
+
+  [_NAV] = KEYMAP(  
+  //,----+----+----+----+----+----+----.     ,----+----+----+----+----+----+----.
+      ,   ,SNAPLEFT,/**/,SNAPRIGHT,,  ,           ,    ,    , UP ,    ,    ,    ,
+  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
+     ,SNAPUP,PREVTAB, ,NEXTTAB,SNAPDOWN,,   ,    ,LEFT,DOWN,RGHT,    ,    ,
+  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
+    ,    ,WORKLEFT,    ,WORKRIGHT,,    ,          ,    ,PGUP,PGDN,    ,    ,    ,
+  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
+                            CDEL ,DEL,                 ,    
+  // \------------------+----+----+---/       \---+----+----+-------------------/
+  ),
+
+  [_TEXTNAV] = KEYMAP(  
+  //,----+----+----+----+----+----+----.     ,----+----+----+----+----+----+----.
+         ,   ,    ,    ,    ,    ,  ,             ,    ,    ,/**/,    ,    ,    ,
+  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
+         ,    ,    ,    ,    ,    ,    ,          ,    ,    ,    ,    ,    ,    ,
+  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
+         ,    ,    ,    ,    ,    ,    ,          ,    ,    ,    ,    ,    ,    ,
+  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
+                                 ,    ,                 ,    
+  // \------------------+----+----+---/       \---+----+----+-------------------/
+  ),
+
+   [_MOUSE] = KEYMAP(  
+  //,----+----+----+----+----+----+----.     ,----+----+----+----+----+----+----.
+         ,    ,    ,MS_UP,   ,   ,    ,      ,    ,    , UP ,    ,    ,    ,/**/
+  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
+      ,   ,MS_LEFT,MS_DOWN,MS_RIGHT,   ,    ,     ,    ,LEFT,DOWN,RGHT,/**/,    ,
+  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
+         ,    ,    ,    ,    ,    ,    ,          ,    ,    ,    ,    ,    ,    ,
+  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
+                      ,MS_BTN1 ,MS_BTN2              ,    
+  // \------------------+----+----+---/       \---+----+----+-------------------/
+  ), 
+
+
+  [_MACROS] = KEYMAP(  
+  //,----+----+----+----+----+----+----.     ,----+----+----+----+----+----+----.
+    /**/,RESET,SECRET_2,SECRET_3,   ,   ,   ,SYSTEM_SLEEP,    ,    ,INCL,    ,    ,    ,
+  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
+     CAD ,SECRET_1,    ,   ,   ,   ,   ,      ,    ,    ,    ,    ,    ,    ,
+  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
+     SCAP,    ,    ,    ,    ,    ,    ,          ,    ,    ,    ,    ,    ,SCAP,
+  //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
+                             ,    ,                    ,    
+  // \------------------+----+----+---/       \---+----+----+-------------------/
+  )
+
+};
+
+
+const uint16_t PROGMEM fn_actions[] = {
+
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
+{
+  switch(id) {
+    /* include some kind of library or header */
+    case 0:
+      if (record->event.pressed) {
+        SEND_STRING("#include <>");
+        return MACRO( T(LEFT), END);
+      }
+      break;
+    case 1:
+      if (record->event.pressed) {
+        SEND_STRING("git pull");
+        return MACRO( T(ENT), END );
+      }
+      break;
+    case 2:
+      if (record->event.pressed){
+        SEND_STRING("git push");
+        return MACRO( T(ENT), END );
+      }
+      break;
+    case 3:
+      if (record->event.pressed){
+        // layer_on(_CAPS);
+        // register_code(KC_CAPSLOCK);
+        // unregister_code(KC_CAPSLOCK);
+      }
+      break;
+    case 4:
+      if (record->event.pressed){
+        // layer_off(_CAPS);
+        // register_code(KC_CAPSLOCK);
+        // unregister_code(KC_CAPSLOCK);
+      }
+      break;
+  }
+  return MACRO_NONE;
+};
+ 
+
+void matrix_scan_user(void) {
+    uint8_t layer = biton32(layer_state);
+    
+    switch (layer) {
+      case _QWERTY:
+        set_led_green;
+        break;
+      case _MOUSE:
+        set_led_yellow;
+        break;
+      case _NUMPAD:
+        set_led_blue;
+        break;
+      case _SYMBOLS:
+        set_led_red;
+        break;
+      case _NAV:
+        set_led_magenta;
+        break;
+      case _MACROS:
+        set_led_green;
+        _delay_ms(45);
+        set_led_red;
+        _delay_ms(45);
+        break;
+      case _FUNCTION:
+        set_led_green;
+        _delay_ms(45);
+        set_led_blue;
+        _delay_ms(45);
+        break;  
+      default:
+        set_led_green;
+        break;
+    }
+};

keyboards/clueboard/60/keymaps/default/keymap.c

@@ -3,11 +3,35 @@
 #define _______ KC_TRNS
 
 enum keyboard_layers {
-  _BL,
+    _BL,
-  _FL,
+    _FL,
-  _CL
+    _CL
 };
 
+enum custom_keycodes {
+    S_BSKTC = SAFE_RANGE,
+    S_ODEJY,
+    S_RCKBY,
+    S_DOEDR,
+    S_SCALE,
+    S_ONEUP,
+    S_COIN,
+    S_SONIC,
+    S_ZELDA
+};
+
+#ifdef AUDIO_ENABLE
+  float song_basketcase[][2] = SONG(BASKET_CASE);
+  float song_ode_to_joy[][2]  = SONG(ODE_TO_JOY);
+  float song_rock_a_bye_baby[][2]  = SONG(ROCK_A_BYE_BABY);
+  float song_doe_a_deer[][2]  = SONG(DOE_A_DEER);
+  float song_scale[][2]  = SONG(MUSIC_SCALE_SOUND);
+  float song_coin[][2]  = SONG(COIN_SOUND);
+  float song_one_up[][2]  = SONG(ONE_UP_SOUND);
+  float song_sonic_ring[][2]  = SONG(SONIC_RING);
+  float song_zelda_puzzle[][2]  = SONG(ZELDA_PUZZLE);
+#endif
+
 const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     /* Layer 0: Default Layer
      * ,-----------------------------------------------------------.
@@ -33,11 +57,71 @@ const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
       _______,   _______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,     \
       _______,     _______,MO(_CL),_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,  _______, \
       _______,  _______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,  _______,   _______, \
-      _______,  _______,  _______,                        _______,                     _______,  _______,  MO(_FL),   _______),
+      _______,_______,_______,                        _______,                     _______,  _______,  MO(_FL),   _______),
     [_CL] = KEYMAP(
-      BL_STEP,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,\
+      BL_STEP,S_BSKTC,S_ODEJY,S_RCKBY,S_DOEDR,S_SCALE,S_ONEUP,S_COIN, S_SONIC,S_ZELDA,_______,_______,_______,_______,_______,\
       _______,   _______,_______,_______,RESET,  _______,_______,_______,_______,_______,_______,_______,_______,_______,     \
       _______,     _______,MO(_CL),_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,  _______, \
       _______,  _______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,     _______, \
       _______,  _______,  _______,                        _______,                     _______,  _______,  MO(_FL),   _______)
 };
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+    switch (keycode) {
+        case S_BSKTC:
+            if (record->event.pressed) {
+                stop_all_notes();
+                PLAY_SONG(song_basketcase);
+            }
+            return false;
+        case S_ODEJY:
+            if (record->event.pressed) {
+                stop_all_notes();
+                PLAY_SONG(song_ode_to_joy);
+            }
+            return false;
+        case S_RCKBY:
+            if (record->event.pressed) {
+                stop_all_notes();
+                PLAY_SONG(song_rock_a_bye_baby);
+            }
+            return false;
+        case S_DOEDR:
+            if (record->event.pressed) {
+                stop_all_notes();
+                PLAY_SONG(song_doe_a_deer);
+            }
+            return false;
+        case S_SCALE:
+            if (record->event.pressed) {
+                stop_all_notes();
+                PLAY_SONG(song_scale);
+            }
+            return false;
+        case S_ONEUP:
+            if (record->event.pressed) {
+                stop_all_notes();
+                PLAY_SONG(song_one_up);
+            }
+            return false;
+        case S_COIN:
+            if (record->event.pressed) {
+                stop_all_notes();
+                PLAY_SONG(song_coin);
+            }
+            return false;
+        case S_SONIC:
+            if (record->event.pressed) {
+                stop_all_notes();
+                PLAY_SONG(song_sonic_ring);
+            }
+            return false;
+        case S_ZELDA:
+            if (record->event.pressed) {
+                stop_all_notes();
+                PLAY_SONG(song_zelda_puzzle);
+            }
+            return false;
+    }
+    return true;
+}

keyboards/clueboard/60/led.c

@@ -23,7 +23,7 @@
 void backlight_init_ports(void) {
     printf("backlight_init_ports()\n");
     #ifdef BACKLIGHT_ENABLE
-    palSetPadMode(GPIOB, 8,  PAL_MODE_OUTPUT_PUSHPULL);
+    palSetPadMode(GPIOB, 8, PAL_MODE_OUTPUT_PUSHPULL);
     palSetPad(GPIOB, 8);
     #endif
 }
@@ -41,13 +41,8 @@ void backlight_set(uint8_t level) {
     #endif
 }
 
-void led_init_ports() {
-    printf("led_init_ports()\n");
-    palSetPadMode(GPIOB, 7,  PAL_MODE_OUTPUT_PUSHPULL);
-}
-
 void led_set_kb(uint8_t usb_led) {
-    printf("led_init_ports()\n");
+    printf("led_set_kb(%d)\n", usb_led);
     if (usb_led & (1<<USB_LED_CAPS_LOCK)) {
         // Turn capslock on
         palSetPad(GPIOB, 7);

keyboards/clueboard/60/matrix.c

@@ -68,13 +68,10 @@ void matrix_init(void) {
     palSetPadMode(GPIOA, 15,  PAL_MODE_INPUT_PULLDOWN);
     palSetPadMode(GPIOA, 10,  PAL_MODE_INPUT_PULLDOWN);
 
-    memset(matrix, 0, MATRIX_ROWS);
+    memset(matrix, 0, MATRIX_ROWS * sizeof(matrix_row_t));
-    memset(matrix_debouncing, 0, MATRIX_COLS);
+    memset(matrix_debouncing, 0, MATRIX_COLS * sizeof(matrix_row_t));
-
-    /* Setup capslock */
-    // palSetPadMode(GPIOB, 7,  PAL_MODE_OUTPUT_PUSHPULL);
-    // palClearPad(GPIOB, 7);
 
+    palClearPad(GPIOB, 7);  // Turn off capslock
     matrix_init_quantum();
 }
 
@@ -138,6 +135,7 @@ uint8_t matrix_scan(void) {
             debouncing_time = timer_read();
         }
     }
+
     if (debouncing && timer_elapsed(debouncing_time) > DEBOUNCE) {
         for (int row = 0; row < MATRIX_ROWS; row++) {
             matrix[row] = 0;

keyboards/clueboard/60/rules.mk

@@ -50,5 +50,5 @@ COMMAND_ENABLE = yes    # Commands for debug and configuration
 #SLEEP_LED_ENABLE = yes  # Breathing sleep LED during USB suspend
 NKRO_ENABLE = yes	    # USB Nkey Rollover
 CUSTOM_MATRIX = yes # Custom matrix file
-#AUDIO_ENABLE = yes
+AUDIO_ENABLE = yes
 # SERIAL_LINK_ENABLE = yes

keyboards/eagle_viper/info.json

@@ -7,7 +7,7 @@
     "height": 5, 
     "layouts": {
         "KEYMAP": {
-            "layout": [{"x":0, "y":0}, {"x":1, "y":0}, {"x":2, "y":0}, {"x":3, "y":0}, {"x":4, "y":0}, {"x":5, "y":0}, {"x":6, "y":0}, {"x":7, "y":0}, {"x":8, "y":0}, {"x":9, "y":0}, {"x":10, "y":0}, {"x":11, "y":0}, {"x":12, "y":0}, {"x":13, "y":0}, {"x":14, "y":0}, {"x":0.5, "y":1, "w":1.5}, {"x":1.5, "y":1}, {"x":2.5, "y":1}, {"x":3.5, "y":1}, {"x":4.5, "y":1}, {"x":5.5, "y":1}, {"x":6.5, "y":1}, {"x":7.5, "y":1}, {"x":8.5, "y":1}, {"x":9.5, "y":1}, {"x":10.5, "y":1}, {"x":11.5, "y":1}, {"x":12.5, "y":1}, {"x":14, "y":1, "w":1.5}, {"x":0.75, "y":2, "w":1.75}, {"x":1.75, "y":2}, {"x":2.75, "y":2}, {"x":3.75, "y":2}, {"x":4.75, "y":2}, {"x":5.75, "y":2}, {"x":6.75, "y":2}, {"x":7.75, "y":2}, {"x":8.75, "y":2}, {"x":9.75, "y":2}, {"x":10.75, "y":2}, {"x":11.75, "y":2}, {"x":14, "y":2, "w":2.25}, {"x":1.25, "y":3, "w":2.25}, {"x":2.25, "y":3}, {"x":3.25, "y":3}, {"x":4.25, "y":3}, {"x":5.25, "y":3}, {"x":6.25, "y":3}, {"x":7.25, "y":3}, {"x":8.25, "y":3}, {"x":9.25, "y":3}, {"x":10.25, "y":3}, {"x":11.25, "y":3}, {"x":13, "y":3, "w":1.75}, {"x":14, "y":3}, {"x":0.25, "y":4, "w":1.25}, {"x":1.5, "y":4, "w":1.25}, {"x":2.75, "y":4, "w":1.25}, {"x":9, "y":4, "w":6.25}, {"x":10.25, "y":4, "w":1.25}, {"x":11.5, "y":4, "w":1.25}, {"x":12.75, "y":4, "w":1.25}, {"x":14, "y":4, "w":1.25}]
+            "layout": [{"label":"Esc", "x":0, "y":0}, {"label":"!", "x":1, "y":0}, {"label":"@", "x":2, "y":0}, {"label":"#", "x":3, "y":0}, {"label":"$", "x":4, "y":0}, {"label":"%", "x":5, "y":0}, {"label":"^", "x":6, "y":0}, {"label":"&", "x":7, "y":0}, {"label":"*", "x":8, "y":0}, {"label":"(", "x":9, "y":0}, {"label":")", "x":10, "y":0}, {"label":"_", "x":11, "y":0}, {"label":"+", "x":12, "y":0}, {"label":"~", "x":13, "y":0}, {"label":"Tab", "x":0, "y":1, "w":1.5}, {"label":"Q", "x":1.5, "y":1}, {"label":"W", "x":2.5, "y":1}, {"label":"E", "x":3.5, "y":1}, {"label":"R", "x":4.5, "y":1}, {"label":"T", "x":5.5, "y":1}, {"label":"Y", "x":6.5, "y":1}, {"label":"U", "x":7.5, "y":1}, {"label":"I", "x":8.5, "y":1}, {"label":"O", "x":9.5, "y":1}, {"label":"P", "x":10.5, "y":1}, {"label":"{", "x":11.5, "y":1}, {"label":"}", "x":12.5, "y":1}, {"label":"|", "x":13.5, "y":1, "w":1.5}, {"label":"Caps Lock", "x":0, "y":2, "w":1.75}, {"label":"A", "x":1.75, "y":2}, {"label":"S", "x":2.75, "y":2}, {"label":"D", "x":3.75, "y":2}, {"label":"F", "x":4.75, "y":2}, {"label":"G", "x":5.75, "y":2}, {"label":"H", "x":6.75, "y":2}, {"label":"J", "x":7.75, "y":2}, {"label":"K", "x":8.75, "y":2}, {"label":"L", "x":9.75, "y":2}, {"label":":", "x":10.75, "y":2}, {"label":"\"", "x":11.75, "y":2}, {"label":"Enter", "x":12.75, "y":2}, {"label":"Enter", "x":13.75, "y":2, "w":1.25}, {"label":"Shift", "x":0, "y":3, "w":1.25}, {"label":"iso", "x":1.25, "y":3}, {"label":"Z", "x":2.25, "y":3}, {"label":"X", "x":3.25, "y":3}, {"label":"C", "x":4.25, "y":3}, {"label":"V", "x":5.25, "y":3}, {"label":"B", "x":6.25, "y":3}, {"label":"N", "x":7.25, "y":3}, {"label":"M", "x":8.25, "y":3}, {"label":"<", "x":9.25, "y":3}, {"label":">", "x":10.25, "y":3}, {"label":"?", "x":11.25, "y":3}, {"label":"Shift", "x":12.25, "y":3, "w":1.75}, {"label":"fn", "x":14, "y":3}, {"label":"Ctrl", "x":0, "y":4, "w":1.5}, {"label":"Win", "x":1.5, "y":4}, {"label":"Alt", "x":2.5, "y":4, "w":1.5}, {"x":4, "y":4, "w":5}, {"x":9, "y":4}, {"x":10, "y":4}, {"label":"Win", "x":11, "y":4, "w":1.5}, {"label":"Menu", "x":12.5, "y":4}, {"label":"Ctrl", "x":13.5, "y":4, "w":1.5}, {"label":"|", "x":13.75, "y":5}]
         }
     }
 }

keyboards/ergodone/ergodone.c

@@ -12,6 +12,8 @@ extern inline void ergodox_right_led_2_off(void);
 extern inline void ergodox_right_led_3_off(void);
 extern inline void ergodox_right_led_off(uint8_t led);
 
+extern inline void ergodox_led_all_off(void);
+
 void ergodox_led_init(void);
 void ergodox_blink_all_leds(void);
 

keyboards/ergodox_infinity/keymaps/gordon/keymap.c

@@ -0,0 +1,315 @@
+#include QMK_KEYBOARD_H
+#include "debug.h"
+#include "action_layer.h"
+#include "version.h"
+#include "process_keycode/process_tap_dance.h"
+#include "gordon.h"
+
+#include "keymap_german.h"
+
+#include "keymap_nordic.h"
+
+
+#define TLSLSH   M(TIL_SLASH)
+#define F1_F13   TD(F1F13)
+#define F2_F14   TD(F2F14)
+#define F5_F15   TD(F5F15)
+#define F4_ALTF4 TD(ALTF4)
+#define END_ESC  TD(ENDESC)
+#define SHF6_AF7 TD(F6F7)
+#define F12_RUN  TD(F12ETAPS)
+#define COMMA_TD TD(COMMA)
+
+enum custom_keycodes {
+  PLACEHOLDER = SAFE_RANGE, // can always be here
+  EPRM,
+  VRSN,
+  RGB_SLD,
+};
+
+//Tap dance enums
+enum {
+  F12TAP = 0,
+  F12ETAPS,
+  CALCCOMP,
+  REFRESH, //send R, or Control+R if double tapped.
+  ENDESC,
+  XESC, //'quad function'. x, control, escape, alt
+  ALY2, //'quad function': a, Hyper, ctrl+a, layer 2
+  PRLOCK,
+  F6F7, // Shift F6 or Alt F7
+  TABCOMBO,
+  FCTRL,
+  F3D,
+  ALTF4,
+  COMMA,
+  AT,
+  HTAB,
+  F1F13,
+  F2F14,
+  F5F15
+};
+
+
+
+// Custom tapping terms for each key.
+// Requires changes to action_taping.c
+/* uint16_t get_tapping_term(keyevent_t* event) {
+    uint16_t keycode = keymap_key_to_keycode(layer_switch_get_layer(event->key), event->key);
+    if (keycode == LT(3,KC_E) ) {
+        return TAPPING_TERM + 50;
+    }
+    return TAPPING_TERM;
+} */
+
+            
+// Tap Dance Definitions
+qk_tap_dance_action_t tap_dance_actions[] = {
+  // simple tap dance
+  [F12ETAPS] = ACTION_TAP_DANCE_DOUBLE(KC_F12,LSFT(LCTL(KC_F10))),  
+  [REFRESH] = ACTION_TAP_DANCE_DOUBLE(KC_R,LCTL(KC_R)),
+  [ENDESC] = ACTION_TAP_DANCE_DOUBLE(KC_END, KC_ESC),
+  [CALCCOMP] = ACTION_TAP_DANCE_DOUBLE(KC_CALCULATOR, KC_MY_COMPUTER),
+  [ALTF4] = ACTION_TAP_DANCE_DOUBLE(KC_F4,LALT(KC_F4)),
+  [F6F7] = ACTION_TAP_DANCE_DOUBLE(LSFT(KC_F6), LALT(KC_F7)),
+  [F1F13] = ACTION_TAP_DANCE_DOUBLE(KC_F1, KC_F13),
+  [F2F14] = ACTION_TAP_DANCE_DOUBLE(KC_F2, KC_F14),
+  [F5F15] = ACTION_TAP_DANCE_DOUBLE(KC_F5, KC_F15),
+  [TABCOMBO] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, tab_finished, tab_reset),
+  [F3D] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, bt_finished, bt_reset),
+  [COMMA] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, comma_finished, comma_reset),
+  [HTAB] = ACTION_TAP_DANCE_FN_ADVANCED(NULL,h_finished, h_reset)
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+
+//**************************FIRST LAYER - LAYER ZERO ************************************** 
+  [_QWERTY] = KEYMAP(
+
+    SHF6_AF7,   F1_F13,    F2_F14,   TD(F3D), F4_ALTF4,    F5_F15,   KC_F11,
+    ________,     KC_Q,  CTR_SH_W,     NAV_E, CTR_AL_R,      KC_T, PRINTSCR,
+      KC_TAB,     KC_A,     MEH_S,  NUMPAD_D,   CTRL_F,     WIN_G,
+    ALT_SHFT,   CTRL_Z,   HYPER_X,   MOUSE_C,    ALT_V,      KC_B, TT(_MOUSE),
+    KC_MINUS, KC_GRAVE, KC_DELETE,   KC_LEFT, KC_RIGHT,
+                                    
+                                              KC_INSERT,  KC_DELETE, 
+                                                           ALT_HOME,
+                                    KC_LSHIFT, SYMB_BSP,    END_ESC,
+
+                 F12_RUN,    KC_F6,    KC_F7,    KC_F8,    KC_F9,    KC_F10, TD(CALCCOMP),
+                ________,     KC_Y,     KC_U,     KC_I,     KC_O,      KC_P,  ________,
+                             WIN_H,   CTRL_J,     KC_K,    MEH_L,  COL_MOUS,  ________,
+                 KC_LEAD,     KC_N,    ALT_M, COMMA_TD, HYPE_DOT,  KC_SLASH, TD(TABCOMBO),
+                                       KC_UP,  KC_DOWN,   KC_ESC,    KC_TILD,    KC_UNDS,
+
+  KC_ESCAPE,  KC_DELETE,
+         ALT_T(KC_PGUP),
+  RCTL_T(KC_PGDOWN), LT(_NAV,KC_ENTER), SPAC_SYM),
+
+
+  //**************************SYMBOLS LAYER**************************
+  [_SYMBOLS] = KEYMAP(
+    ________, ________, ________, ________, ________, ________,  ________,
+    ________,   TLSLSH,    KC_AT,  KC_LCBR,  KC_RCBR,  KC_CIRC,  ________,
+    ________,  KC_EXLM,  KC_PIPE,  KC_LPRN,  KC_RPRN, M(DEREF),
+    ________,KC_DOLLAR,  KC_PERC, LSQUIGLY, RSQUIGLY, ________,  ________,
+    ________,  M(TICK3),  ________,  ________,  ________,  
+
+                                    ________,________,
+                                             ________,
+                           ________,________,________,
+
+
+                  ________, ________, ________, ________, ________, ________, NUMLOCK,
+                  ________,   TLSLSH,  KC_PIPE,  KC_PLUS,  KC_AMPR, ________, CAPLOCK,
+                          M(EQRIGHT),  KC_DQUO, KC_EQUAL, KC_QUOTE,KC_SCOLON, ________,
+                  ________,  KC_PIPE, BK_SLASH,  ASTERSK,   KC_DOT, KC_SLASH, ________,
+                  ________,________,________,M(TILD3),________,
+                                                              ________,________,
+                                                                       ________,
+                                                     ________,________,________),
+  
+  //**************************MOUSE MOVEMENT LAYER**************************
+  [_MOUSE] = KEYMAP(RESET,________,________,________,________,________,________,
+                    RESET,________,________,KC_MS_UP,________,KC_MS_WH_UP,CALTDEL,
+                    ________,________,KC_MS_LEFT,KC_MS_DOWN,KC_MS_RIGHT,KC_MS_WH_DOWN,
+                    KC_SECRET_1,________,HYPR(KC_F13),________,HYPR(KC_F14),KC_SECRET_2,________,
+                    ________,________,HYPR(KC_F15),KC_MS_WH_LEFT,KC_MS_WH_RIGHT,
+                    
+                                                       ________,________,
+                                                                ________,
+                                          KC_MS_BTN1,KC_MS_BTN2,________,
+                                          
+                                         
+                    ________,________,________,________,________,________,________,
+                    KC_MS_WH_UP,________,________,KC_UP,________,________,________,
+                    ________,KC_LEFT,KC_DOWN,KC_RIGHT,________,________,
+                    KC_MS_WH_DOWN,________,KC_PGUP,KC_PGDOWN,KC_MEDIA_NEXT_TRACK,________,________,
+                    KC_AUDIO_VOL_UP,KC_AUDIO_VOL_DOWN,KC_AUDIO_MUTE,KC_MEDIA_PLAY_PAUSE,________,
+                    ________,________,
+                    ________,
+                    ________,________,KC_WWW_BACK),
+
+
+
+
+  //**************************WINDOWS NAVIGATION LAYER**************************
+
+  [_NAV] = KEYMAP(________,________,________,________,________,________,________,
+                  ________,________,SNAPLEFT,________,SNAPRGHT,LALT(KC_LEFT),________,
+                  ________,LCTL(KC_W),PREVTAB,LGUI(KC_D),NEXTTAB,________,
+                  ________,________,WORKLEFT,________,WORKRIGHT,________,________,
+                  ________,________,________,________,________,
+                  
+                  ________,________,
+                           ________,
+         ________,________,________, 
+         
+         
+         ________,________,________,________,________,________,________,
+         ________,________,SNAPUP  ,KC_UP   ,SNAPDOWN,________,________,
+                  ________,KC_LEFT ,KC_DOWN ,KC_RIGHT,________,________,
+         ________,________,________,________,________,________,________,
+         ________,________,________,________,________,
+         
+         
+         ________,________,
+         ________,
+         ________,________,________),
+
+  //****************************NUMPAD LAYER****************************
+  [_NUMPAD] = KEYMAP(________,________,________,________,________,________,________,
+                     ________,________,________,________,________,________,________,
+                     ________,________,________,________,________,________,
+                     ________,________,________,________,________,________,________,
+                     ________,________,________,________,________,
+                     
+                     ________,________,
+                     ________,
+                     ________,________,________,
+                     
+                     BL_TOGG ,BL_STEP ,________,________,________,________,________,
+                     ________,________,KC_7    ,KC_8    ,KC_9    ,________,________,
+                              ________,KC_4    ,KC_5    ,KC_6    ,________,________,
+                     ________,________,KC_1    ,KC_2    ,KC_3    ,________,________,
+                                       KC_0    ,KC_0 ,  KC_DOT   ,________,________,
+                                       
+                                       ________,________,
+                                       ________,
+                                       ________,________,KC_0),
+  //****************************TEXT/INTELLIJ NAVIGATION LAYER****************************
+  [_TEXTNAV] = KEYMAP(________,________,________,________,________,________,________,
+                      ________,MEH(KC_Q),LSFT(KC_ESCAPE),MEH(KC_D),MEH(KC_2),LALT(LSFT(KC_UP)),________,
+                      ________,LALT(KC_F7),LCTL(KC_LEFT),LCTL(KC_B),LCTL(KC_RIGHT),LALT(LSFT(KC_DOWN)),
+                      ________,________,________,LCTL(LSFT(KC_COMMA)),MEH(KC_DOT),LALT(KC_MS_WH_UP),________,________,________,________,________,________,________,________,________,________,LCTL(KC_DELETE),________,LALT(LSFT(KC_F9)),________,________,________,________,________,________,________,MEH(KC_5),LALT(LSFT(KC_Z)),________,LALT(KC_Z),________,________,________,LCTL(LSFT(KC_LEFT)),LALT(LCTL(KC_S)),LCTL(LSFT(KC_RIGHT)),LCTL(LSFT(KC_COMMA)),________,________,________,________,________,________,________,________,________,________,________,________,________,________,________,________,________,________,________)
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+  [1] = ACTION_LAYER_TAP_TOGGLE(1)
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
+{
+      switch(id) {
+        case INFOQM: {
+          if (record->event.pressed) {
+            SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
+          }
+          break;
+        }
+
+        case TIL_SLASH: {
+          if (record->event.pressed) {
+            SEND_STRING ("~/.");
+          }
+          break;
+        }
+
+        case DEREF: {
+          if (record->event.pressed) {
+            SEND_STRING ("->");
+          }
+          break;
+        }
+        
+        case EQRIGHT: {
+          if (record->event.pressed) {
+            SEND_STRING ("=>");
+          }
+          break;
+        }
+
+        case TICK3: {
+          if (record->event.pressed) {
+            SEND_STRING ("```");
+          }
+          break;
+        }
+
+        case TILD3: {
+          if (record->event.pressed) {
+            SEND_STRING ("~~~");
+          }
+          break;
+        }
+
+        case ALTTAB_START: {
+          register_code(KC_LALT);
+          layer_on(8);
+        }
+
+        case ALTTAB_END: {
+          unregister_code(KC_LALT);
+          layer_off(8);
+        }
+
+
+
+      }
+      return MACRO_NONE;
+};
+
+void matrix_scan_user(void) {
+
+    uint8_t layer = biton32(layer_state);
+
+    ergodox_board_led_on();
+    ergodox_led_all_on();
+
+    ergodox_board_led_off();
+    ergodox_right_led_1_off();
+    ergodox_right_led_2_off();
+    ergodox_right_led_3_off();
+    switch (layer) {
+        case _SYMBOLS:
+            ergodox_right_led_1_on();
+            break;
+        case _MOUSE:
+            ergodox_right_led_2_on();
+            break;
+        case _NUMPAD:
+            ergodox_right_led_3_on();
+            break;
+        case _NAV:
+            ergodox_right_led_1_on();
+            ergodox_right_led_2_on();
+            break;
+        case 5:
+            ergodox_right_led_1_on();
+            ergodox_right_led_3_on();
+            break;
+        case 6:
+            ergodox_right_led_2_on();
+            ergodox_right_led_3_on();
+            break;
+        case 7:
+            ergodox_right_led_1_on();
+            ergodox_right_led_2_on();
+            ergodox_right_led_3_on();
+            break;
+        default:
+            break;
+    }
+
+};

keyboards/ergodox_infinity/matrix.c

@@ -62,8 +62,8 @@ void matrix_init(void)
     palSetPadMode(GPIOC, 11, PAL_MODE_OUTPUT_PUSHPULL);
     palSetPadMode(GPIOD, 0,  PAL_MODE_OUTPUT_PUSHPULL);
 
-    memset(matrix, 0, MATRIX_ROWS);
+    memset(matrix, 0, MATRIX_ROWS * sizeof(matrix_row_t));
-    memset(matrix_debouncing, 0, LOCAL_MATRIX_ROWS);
+    memset(matrix_debouncing, 0, LOCAL_MATRIX_ROWS * sizeof(matrix_row_t));
 
     matrix_init_quantum();
 }

keyboards/infinity60/matrix.c

@@ -60,8 +60,8 @@ void matrix_init(void)
     palSetPadMode(GPIOC, 5,  PAL_MODE_OUTPUT_PUSHPULL);
     palSetPadMode(GPIOD, 0,  PAL_MODE_OUTPUT_PUSHPULL);
 #endif
-    memset(matrix, 0, MATRIX_ROWS);
+    memset(matrix, 0, MATRIX_ROWS * sizeof(matrix_row_t));
-    memset(matrix_debouncing, 0, MATRIX_ROWS);
+    memset(matrix_debouncing, 0, MATRIX_ROWS * sizeof(matrix_row_t));
 
     matrix_init_quantum();
 }

keyboards/jm60/matrix.c

@@ -49,8 +49,8 @@ void matrix_init(void)
     palSetPadMode(GPIOB, 1, PAL_MODE_OUTPUT_PUSHPULL);
     palSetPadMode(GPIOB, 0,  PAL_MODE_OUTPUT_PUSHPULL);
 
-    memset(matrix, 0, MATRIX_ROWS);
+    memset(matrix, 0, MATRIX_ROWS * sizeof(matrix_row_t));
-    memset(matrix_debouncing, 0, MATRIX_ROWS);
+    memset(matrix_debouncing, 0, MATRIX_ROWS * sizeof(matrix_row_t));
 }
 
 uint8_t matrix_scan(void)

keyboards/k_type/matrix.c

@@ -42,8 +42,8 @@ void matrix_init(void)
     palSetPadMode(GPIOD, 1,   PAL_MODE_OUTPUT_PUSHPULL);
     palSetPadMode(GPIOD, 4,   PAL_MODE_OUTPUT_PUSHPULL);
 
-    memset(matrix, 0, MATRIX_ROWS);
+    memset(matrix, 0, MATRIX_ROWS * sizeof(matrix_row_t));
-    memset(matrix_debouncing, 0, MATRIX_ROWS);
+    memset(matrix_debouncing, 0, MATRIX_ROWS * sizeof(matrix_row_t));
 
     matrix_init_quantum();
 }

keyboards/planck/keymaps/audio_out/config.h

@@ -0,0 +1,47 @@
+#ifndef CONFIG_USER_H
+#define CONFIG_USER_H
+
+#include "config_common.h"
+
+#ifdef AUDIO_ENABLE
+    #define STARTUP_SONG SONG(PLANCK_SOUND)
+    // #define STARTUP_SONG SONG(NO_SOUND)
+
+    #define DEFAULT_LAYER_SONGS { SONG(QWERTY_SOUND), \
+                                  SONG(COLEMAK_SOUND), \
+                                  SONG(DVORAK_SOUND) \
+                                }
+#endif
+
+#define MUSIC_MASK (keycode != KC_NO)
+
+/*
+ * MIDI options
+ */
+
+/* Prevent use of disabled MIDI features in the keymap */
+//#define MIDI_ENABLE_STRICT 1
+
+/* enable basic MIDI features:
+   - MIDI notes can be sent when in Music mode is on
+*/
+                                
+#define MIDI_BASIC
+
+/* enable advanced MIDI features:
+   - MIDI notes can be added to the keymap
+   - Octave shift and transpose
+   - Virtual sustain, portamento, and modulation wheel
+   - etc.
+*/
+//#define MIDI_ADVANCED
+
+/* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
+//#define MIDI_TONE_KEYCODE_OCTAVES 2
+
+#define C6_AUDIO
+#define B7_AUDIO
+
+#undef BACKLIGHT_PIN
+
+#endif

keyboards/planck/keymaps/audio_out/keymap.c

@@ -0,0 +1,264 @@
+/* Copyright 2015-2017 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/>.
+ */
+
+#include "planck.h"
+#include "action_layer.h"
+
+extern keymap_config_t keymap_config;
+
+enum planck_layers {
+  _QWERTY,
+  _COLEMAK,
+  _DVORAK,
+  _LOWER,
+  _RAISE,
+  _PLOVER,
+  _ADJUST
+};
+
+enum planck_keycodes {
+  QWERTY = SAFE_RANGE,
+  COLEMAK,
+  DVORAK,
+  PLOVER,
+  LOWER,
+  RAISE,
+  BACKLIT,
+  EXT_PLV
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+/* Qwerty
+ * ,-----------------------------------------------------------------------------------.
+ * | Tab  |   Q  |   W  |   E  |   R  |   T  |   Y  |   U  |   I  |   O  |   P  | Bksp |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * | Esc  |   A  |   S  |   D  |   F  |   G  |   H  |   J  |   K  |   L  |   ;  |  "   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * | Shift|   Z  |   X  |   C  |   V  |   B  |   N  |   M  |   ,  |   .  |   /  |Enter |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * | Brite| Ctrl | Alt  | GUI  |Lower |    Space    |Raise | Left | Down |  Up  |Right |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_QWERTY] = {
+  {KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_BSPC},
+  {KC_ESC,  KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT},
+  {KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_ENT },
+  {BACKLIT, KC_LCTL, KC_LALT, KC_LGUI, LOWER,   KC_SPC,  KC_SPC,  RAISE,   KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT}
+},
+
+/* Colemak
+ * ,-----------------------------------------------------------------------------------.
+ * | Tab  |   Q  |   W  |   F  |   P  |   G  |   J  |   L  |   U  |   Y  |   ;  | Bksp |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * | Esc  |   A  |   R  |   S  |   T  |   D  |   H  |   N  |   E  |   I  |   O  |  "   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * | Shift|   Z  |   X  |   C  |   V  |   B  |   K  |   M  |   ,  |   .  |   /  |Enter |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * | Brite| Ctrl | Alt  | GUI  |Lower |    Space    |Raise | Left | Down |  Up  |Right |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_COLEMAK] = {
+  {KC_TAB,  KC_Q,    KC_W,    KC_F,    KC_P,    KC_G,    KC_J,    KC_L,    KC_U,    KC_Y,    KC_SCLN, KC_BSPC},
+  {KC_ESC,  KC_A,    KC_R,    KC_S,    KC_T,    KC_D,    KC_H,    KC_N,    KC_E,    KC_I,    KC_O,    KC_QUOT},
+  {KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_K,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_ENT },
+  {BACKLIT, KC_LCTL, KC_LALT, KC_LGUI, LOWER,   KC_SPC,  KC_SPC,  RAISE,   KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT}
+},
+
+/* Dvorak
+ * ,-----------------------------------------------------------------------------------.
+ * | Tab  |   "  |   ,  |   .  |   P  |   Y  |   F  |   G  |   C  |   R  |   L  | Bksp |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * | Esc  |   A  |   O  |   E  |   U  |   I  |   D  |   H  |   T  |   N  |   S  |  /   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * | Shift|   ;  |   Q  |   J  |   K  |   X  |   B  |   M  |   W  |   V  |   Z  |Enter |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * | Brite| Ctrl | Alt  | GUI  |Lower |    Space    |Raise | Left | Down |  Up  |Right |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_DVORAK] = {
+  {KC_TAB,  KC_QUOT, KC_COMM, KC_DOT,  KC_P,    KC_Y,    KC_F,    KC_G,    KC_C,    KC_R,    KC_L,    KC_BSPC},
+  {KC_ESC,  KC_A,    KC_O,    KC_E,    KC_U,    KC_I,    KC_D,    KC_H,    KC_T,    KC_N,    KC_S,    KC_SLSH},
+  {KC_LSFT, KC_SCLN, KC_Q,    KC_J,    KC_K,    KC_X,    KC_B,    KC_M,    KC_W,    KC_V,    KC_Z,    KC_ENT },
+  {BACKLIT, KC_LCTL, KC_LALT, KC_LGUI, LOWER,   KC_SPC,  KC_SPC,  RAISE,   KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT}
+},
+
+/* Lower
+ * ,-----------------------------------------------------------------------------------.
+ * |   ~  |   !  |   @  |   #  |   $  |   %  |   ^  |   &  |   *  |   (  |   )  | Bksp |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * | Del  |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |   _  |   +  |   {  |   }  |  |   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |      |  F7  |  F8  |  F9  |  F10 |  F11 |  F12 |ISO ~ |ISO | | Home | End  |      |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |      |      |      |      |      |             |      | Next | Vol- | Vol+ | Play |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_LOWER] = {
+  {KC_TILD, KC_EXLM, KC_AT,   KC_HASH, KC_DLR,  KC_PERC, KC_CIRC, KC_AMPR,    KC_ASTR,    KC_LPRN, KC_RPRN, KC_BSPC},
+  {KC_DEL,  KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_UNDS,    KC_PLUS,    KC_LCBR, KC_RCBR, KC_PIPE},
+  {_______, KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  S(KC_NUHS), S(KC_NUBS), KC_HOME, KC_END,  _______},
+  {_______, _______, _______, _______, _______, _______, _______, _______,    KC_MNXT,    KC_VOLD, KC_VOLU, KC_MPLY}
+},
+
+/* Raise
+ * ,-----------------------------------------------------------------------------------.
+ * |   `  |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   0  | Bksp |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * | Del  |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |   -  |   =  |   [  |   ]  |  \   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |      |  F7  |  F8  |  F9  |  F10 |  F11 |  F12 |ISO # |ISO / |Pg Up |Pg Dn |      |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |      |      |      |      |      |             |      | Next | Vol- | Vol+ | Play |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_RAISE] = {
+  {KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSPC},
+  {KC_DEL,  KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_MINS, KC_EQL,  KC_LBRC, KC_RBRC, KC_BSLS},
+  {_______, KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  KC_NUHS, KC_NUBS, KC_PGUP, KC_PGDN, _______},
+  {_______, _______, _______, _______, _______, _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
+},
+
+/* Plover layer (http://opensteno.org)
+ * ,-----------------------------------------------------------------------------------.
+ * |   #  |   #  |   #  |   #  |   #  |   #  |   #  |   #  |   #  |   #  |   #  |   #  |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * |      |   S  |   T  |   P  |   H  |   *  |   *  |   F  |   P  |   L  |   T  |   D  |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |      |   S  |   K  |   W  |   R  |   *  |   *  |   R  |   B  |   G  |   S  |   Z  |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * | Exit |      |      |   A  |   O  |             |   E  |   U  |      |      |      |
+ * `-----------------------------------------------------------------------------------'
+ */
+
+[_PLOVER] = {
+  {KC_1,    KC_1,    KC_1,    KC_1,    KC_1,    KC_1,    KC_1,    KC_1,    KC_1,    KC_1,    KC_1,    KC_1   },
+  {XXXXXXX, KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC},
+  {XXXXXXX, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT},
+  {EXT_PLV, XXXXXXX, XXXXXXX, KC_C,    KC_V,    XXXXXXX, XXXXXXX, KC_N,    KC_M,    XXXXXXX, XXXXXXX, XXXXXXX}
+},
+
+/* Adjust (Lower + Raise)
+ * ,-----------------------------------------------------------------------------------.
+ * |      | Reset|      |      |      |      |      |      |      |      |      |  Del |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * |      |      |      |Aud on|Audoff|AGnorm|AGswap|Qwerty|Colemk|Dvorak|Plover|      |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |      |Voice-|Voice+|Mus on|Musoff|MIDIon|MIDIof|      |      |      |      |      |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |      |      |      |      |      |             |      |      |      |      |      |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_ADJUST] = {
+  {_______, RESET,   DEBUG,    RGB_TOG, RGB_MOD, RGB_HUI, RGB_HUD, RGB_SAI, RGB_SAD, RGB_VAI, RGB_VAD, KC_DEL },
+  {_______, _______, MU_MOD,  AU_ON,   AU_OFF,  AG_NORM, AG_SWAP, QWERTY,  COLEMAK, DVORAK,  PLOVER,  _______},
+  {_______, MUV_DE,  MUV_IN,  MU_ON,   MU_OFF,  MI_ON,   MI_OFF,  TERM_ON, TERM_OFF, _______, _______, _______},
+  {_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______}
+}
+
+
+};
+
+#ifdef AUDIO_ENABLE
+  float plover_song[][2]     = SONG(PLOVER_SOUND);
+  float plover_gb_song[][2]  = SONG(PLOVER_GOODBYE_SOUND);
+#endif
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case QWERTY:
+      if (record->event.pressed) {
+        print("mode just switched to qwerty and this is a huge string\n");
+        set_single_persistent_default_layer(_QWERTY);
+      }
+      return false;
+      break;
+    case COLEMAK:
+      if (record->event.pressed) {
+        set_single_persistent_default_layer(_COLEMAK);
+      }
+      return false;
+      break;
+    case DVORAK:
+      if (record->event.pressed) {
+        set_single_persistent_default_layer(_DVORAK);
+      }
+      return false;
+      break;
+    case LOWER:
+      if (record->event.pressed) {
+        layer_on(_LOWER);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      } else {
+        layer_off(_LOWER);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      }
+      return false;
+      break;
+    case RAISE:
+      if (record->event.pressed) {
+        layer_on(_RAISE);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      } else {
+        layer_off(_RAISE);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      }
+      return false;
+      break;
+    case BACKLIT:
+      if (record->event.pressed) {
+        register_code(KC_RSFT);
+        #ifdef BACKLIGHT_ENABLE
+          backlight_step();
+        #endif
+        PORTE &= ~(1<<6);
+      } else {
+        unregister_code(KC_RSFT);
+        PORTE |= (1<<6);
+      }
+      return false;
+      break;
+    case PLOVER:
+      if (record->event.pressed) {
+        #ifdef AUDIO_ENABLE
+          stop_all_notes();
+          PLAY_SONG(plover_song);
+        #endif
+        layer_off(_RAISE);
+        layer_off(_LOWER);
+        layer_off(_ADJUST);
+        layer_on(_PLOVER);
+        if (!eeconfig_is_enabled()) {
+            eeconfig_init();
+        }
+        keymap_config.raw = eeconfig_read_keymap();
+        keymap_config.nkro = 1;
+        eeconfig_update_keymap(keymap_config.raw);
+      }
+      return false;
+      break;
+    case EXT_PLV:
+      if (record->event.pressed) {
+        #ifdef AUDIO_ENABLE
+          PLAY_SONG(plover_gb_song);
+        #endif
+        layer_off(_PLOVER);
+      }
+      return false;
+      break;
+  }
+  return true;
+}

keyboards/planck/keymaps/audio_out/rules.mk

@@ -0,0 +1,3 @@
+AUDIO_ENABLE = yes
+BACKLIGHT_ENABLE = no
+MIDI_ENABLE = no

keyboards/planck/rules.mk

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

keyboards/preonic/info.json

@@ -10,7 +10,7 @@
   "width": 12,
   "height": 5,
   "layouts": {
-    "LAYOUT_preonic_mit": {
+    "KEYMAP": {
       "key_count": 59,
       "layout": [ 
         { "w": 1, "x": 0, "y": 0 }, 

keyboards/tada68/keymaps/trashcat/keymap.c

@@ -0,0 +1,113 @@
+#include "tada68.h"
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+#define _BL 0
+#define _FL 1
+#define _GM 2
+#define _GF 3
+
+#define _______ KC_TRNS
+
+// Tap dance declarations (These must go above the keymaps)
+enum {
+  TD_F1 = 0,
+  TD_F2,
+  TD_F3,
+  TD_F4,
+  TD_F5,
+  TD_F6,
+  TD_F7,
+  TD_F8,
+  TD_F9,
+  TD_F10,
+  TD_F11,
+  TD_F12,
+  TD_AE_FITCOMP,
+  TD_AE_IN,
+  TD_AE_OUT
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  /* Keymap _BL: (Base Layer) Default Layer
+   * ,----------------------------------------------------------------.
+   * |Esc | 1|  2|  3|  4|  5|  6|  7|  8|  9|  0|  -|  =|   \   |~ ` |
+   * |----------------------------------------------------------------|
+   * |Tab  |  Q|  W|  E|  R|  T|  Y|  U|  I|  O|  P|  [|  ]|Bksp |Del |
+   * |----------------------------------------------------------------|
+   * |Ctrl   |  A|  S|  D|  F|  G|  H|  J|  K|  L|  ;|  '|Return |PgUp|
+   * |----------------------------------------------------------------|
+   * |Shift   |  Z|  X|  C|  V|  B|  N|  M|  ,|  .|  /|Shift | Up|PgDn|
+   * |----------------------------------------------------------------|
+   * |Ctrl|Win |Alt |        Space          |FN| Alt|Ctrl|Lef|Dow|Rig |
+   * `----------------------------------------------------------------'
+   */
+[_BL] = KEYMAP_ANSI(
+  KC_ESC, TD(TD_F1), TD(TD_F2), TD(TD_F3), TD(TD_F4), TD(TD_F5), TD(TD_F6), TD(TD_F7), TD(TD_F8), TD(TD_F9), TD(TD_F10), TD(TD_F11), TD(TD_F12), KC_BSLS,KC_GRV, \
+  KC_TAB,  KC_Q,   KC_W,   KC_E,   KC_R,   KC_T,   KC_Y,   KC_U,   KC_I,   KC_O,   KC_P,   KC_LBRC, KC_RBRC,KC_BSPC,KC_DEL, \
+  KC_LCTRL, KC_A,   KC_S,   KC_D,   KC_F,   KC_G,   KC_H,   KC_J,   KC_K,   KC_L,   KC_SCLN,KC_QUOT,         KC_ENT,KC_PGUP,  \
+  KC_LSFT,         KC_Z,   KC_X,   KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM,KC_DOT, KC_SLSH,   KC_RSFT,KC_UP,KC_PGDN, \
+  KC_LCTL, KC_LGUI,KC_LALT,                KC_SPC,                        MO(_FL),KC_RALT,KC_RCTRL, KC_LEFT,KC_DOWN,KC_RGHT),
+
+  /* Keymap _FL: Function Layer
+   * ,----------------------------------------------------------------.
+   * |   | F1|F2 |F3 |F4 |F5 |F6 |F7 |F8 |F9 |F10|F11|F12|  _GM  |Ins |
+   * |----------------------------------------------------------------|
+   * |     |   |Up |   |   |   |   |   |   |   |   |   |   |     |Hme |
+   * |----------------------------------------------------------------|
+   * | Caps |<- |Dn | ->|   |   |   |   |   |   |   |   |        |End |
+   * |----------------------------------------------------------------|
+   * |        |   |   |Bl-|BL |BL+|   |VU-|VU+|MUT|   |   McL|MsU|McR |
+   * |----------------------------------------------------------------|
+   * |    |    |    |                       |   |   |   |Prev|P/P|Next|
+   * `----------------------------------------------------------------'
+   */
+[_FL] = KEYMAP_ANSI(
+  _______, KC_F1 ,KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, _______, KC_INS ,  \
+  _______,_______, KC_UP,_______,_______, _______,_______,_______,_______,_______,_______,_______,_______, _______,KC_HOME, \
+  KC_CAPS,KC_LEFT,KC_DOWN,KC_RIGHT,_______,_______,_______,_______,_______,_______,_______,_______,        _______,KC_END, \
+  _______,_______,_______,BL_DEC, BL_TOGG,BL_INC, _______,KC_VOLD,KC_VOLU,KC_MUTE,_______,_______, _______, _______, \
+  _______,_______,_______,                 TG(_GM),               _______,_______,_______,KC_MPRV,KC_MPLY, KC_MNXT),
+
+  /* Keymap _GL: Gaming Layer. Basically makes Caps Lock behave normally. I know there is a better way to do this but copy and paste was my friend
+   * ,----------------------------------------------------------------.
+   * |Esc | 1|  2|  3|  4|  5|  6|  7|  8|  9|  0|  -|  =|   \   |~ ` |
+   * |----------------------------------------------------------------|
+   * |Tab  |  Q|  W|  E|  R|  T|  Y|  U|  I|  O|  P|  [|  ]|Bksp |Del |
+   * |----------------------------------------------------------------|
+   * |Caps   |  A|  S|  D|  F|  G|  H|  J|  K|  L|  ;|  '|Return |PgUp|
+   * |----------------------------------------------------------------|
+   * |Shift   |  Z|  X|  C|  V|  B|  N|  M|  ,|  .|  /|Shift | Up|PgDn|
+   * |----------------------------------------------------------------|
+   * |Ctrl|Win |Alt |        Space          |FN| Alt|Ctrl|Lef|Dow|Rig |
+   * `----------------------------------------------------------------'
+   */
+[_GM] = KEYMAP_ANSI(
+  KC_ESC,TD(TD_F1), TD(TD_F2), TD(TD_F3), TD(TD_F4), TD(TD_F5), TD(TD_F6), TD(TD_F7), TD(TD_F8), TD(TD_F9), TD(TD_F10), TD(TD_F11), TD(TD_F12), _______, KC_GRV, \
+  KC_TAB,  KC_Q,   KC_W,   KC_E,   KC_R,   KC_T,   KC_Y,   KC_U,   KC_I,   KC_O,   KC_P,   KC_LBRC, KC_RBRC,KC_BSPC,KC_DEL, \
+  KC_CAPS, KC_A,   KC_S,   KC_D,   KC_F,   KC_G,   KC_H,   KC_J,   KC_K,   KC_L,   KC_SCLN,KC_QUOT,         KC_ENT,KC_PGUP,  \
+  KC_LSFT,         KC_Z,   KC_X,   KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM,KC_DOT, KC_SLSH,   KC_RSFT,KC_UP,KC_PGDN, \
+  KC_LCTL, KC_LGUI,KC_LALT,                _______,                        MO(_FL),KC_RALT,KC_RCTRL, KC_LEFT,KC_DOWN,KC_RGHT),
+
+};
+
+// Tapdance definitions. Tap Dance F Keys.
+qk_tap_dance_action_t tap_dance_actions[] = {
+  [TD_F1] = ACTION_TAP_DANCE_DOUBLE(KC_1, KC_F1),
+  [TD_F2] = ACTION_TAP_DANCE_DOUBLE(KC_2, KC_F2),
+  [TD_F3] = ACTION_TAP_DANCE_DOUBLE(KC_3, KC_F3),
+  [TD_F4] = ACTION_TAP_DANCE_DOUBLE(KC_4, KC_F4),
+  [TD_F5] = ACTION_TAP_DANCE_DOUBLE(KC_5, KC_F5),
+  [TD_F6] = ACTION_TAP_DANCE_DOUBLE(KC_6, KC_F6),
+  [TD_F7] = ACTION_TAP_DANCE_DOUBLE(KC_7, KC_F7),
+  [TD_F8] = ACTION_TAP_DANCE_DOUBLE(KC_8, KC_F8),
+  [TD_F9] = ACTION_TAP_DANCE_DOUBLE(KC_9, KC_F9),
+  [TD_F10] = ACTION_TAP_DANCE_DOUBLE(KC_0, KC_F10),
+  [TD_F11] = ACTION_TAP_DANCE_DOUBLE(KC_MINS, KC_F11),
+  [TD_F12] = ACTION_TAP_DANCE_DOUBLE(KC_EQL, KC_F12),
+  [TD_AE_FITCOMP] = ACTION_TAP_DANCE_DOUBLE(KC_SLSH, LALT(KC_SLSH)),
+  [TD_AE_IN] = ACTION_TAP_DANCE_DOUBLE(KC_LBRC, LALT(KC_LBRC)),
+[TD_AE_OUT] = ACTION_TAP_DANCE_DOUBLE(KC_RBRC, LALT(KC_RBRC))
+};

keyboards/tada68/keymaps/trashcat/readme.md

@@ -0,0 +1,7 @@
+# Trashcat's Tada68
+
+Just my simple layout for the Tada68.  
+Caps Lock behaves as LCtrl until switched to the Gaming Layer. I have a stupid reason for why I need caps lock at all but I won't get into it.  
+LCtrl is also LCtrl because I had no idea what else to put there.  
+
+Tap Dance for the F Row.. i.e double tap 1 and get F1 instead. 

keyboards/tada68/keymaps/trashcat/rules.mk

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

keyboards/whitefox/matrix.c

@@ -47,8 +47,9 @@ void matrix_init(void)
     palSetPadMode(GPIOC, 10, PAL_MODE_OUTPUT_PUSHPULL);
     palSetPadMode(GPIOC, 11, PAL_MODE_OUTPUT_PUSHPULL);
 
-    memset(matrix, 0, MATRIX_ROWS);
+    memset(matrix, 0, MATRIX_ROWS * sizeof(matrix_row_t));
-    memset(matrix_debouncing, 0, MATRIX_ROWS);
+    memset(matrix_debouncing, 0, MATRIX_ROWS * sizeof(matrix_row_t));
+
     matrix_init_quantum();
 }
 

message.mk

@@ -58,7 +58,7 @@ MSG_SUBMODULE_DIRTY = $(WARN_COLOR)WARNING:$(NO_COLOR)\n \
 	Some git sub-modules are out of date or modified, please consider runnning:$(BOLD)\n\
         make git-submodule\n\
 	You can ignore this warning if you are not compiling any ChibiOS keyboards,\n\
-	or if you have modified the ChibiOS libraries yourself. \n\n
+	or if you have modified the ChibiOS libraries yourself. \n\n$(NO_COLOR)
 MSG_NO_CMP = $(ERROR_COLOR)Error:$(NO_COLOR)$(BOLD) cmp command not found, please install diffutils\n$(NO_COLOR)
 
 define GENERATE_MSG_MAKE_KB

quantum/audio/audio.c

@@ -47,6 +47,16 @@
     #define DISABLE_AUDIO_COUNTER_1_ISR TIMSK1 &= ~_BV(OCIE1A)
 #endif
 
+#ifdef B6_AUDIO
+    #define ENABLE_AUDIO_COUNTER_1_ISR TIMSK1 |= _BV(OCIE1B)
+    #define DISABLE_AUDIO_COUNTER_1_ISR TIMSK1 &= ~_BV(OCIE1B)
+#endif
+
+#ifdef B7_AUDIO
+    #define ENABLE_AUDIO_COUNTER_1_ISR TIMSK1 |= _BV(OCIE1C)
+    #define DISABLE_AUDIO_COUNTER_1_ISR TIMSK1 &= ~_BV(OCIE1C)
+#endif
+
 // TCCR3A: Timer/Counter #3 Control Register
 // Compare Output Mode (COM3An) = 0b00 = Normal port operation, OC3A disconnected from PC6
 
@@ -60,6 +70,16 @@
     #define DISABLE_AUDIO_COUNTER_1_OUTPUT TCCR1A &= ~(_BV(COM1A1) | _BV(COM1A0));
 #endif
 
+#ifdef B6_AUDIO
+    #define ENABLE_AUDIO_COUNTER_1_OUTPUT TCCR1A |= _BV(COM1B1);
+    #define DISABLE_AUDIO_COUNTER_1_OUTPUT TCCR1A &= ~(_BV(COM1B1) | _BV(COM1B0));
+#endif
+
+#ifdef B7_AUDIO
+    #define ENABLE_AUDIO_COUNTER_1_OUTPUT TCCR1A |= _BV(COM1C1);
+    #define DISABLE_AUDIO_COUNTER_1_OUTPUT TCCR1A &= ~(_BV(COM1C1) | _BV(COM1C0));
+#endif
+
 // Fast PWM Mode Controls
 
 #ifdef C6_AUDIO
@@ -72,6 +92,16 @@
     #define TIMER_1_DUTY_CYCLE OCR1A
 #endif
 
+#ifdef B6_AUDIO
+    #define TIMER_1_PERIOD     ICR1
+    #define TIMER_1_DUTY_CYCLE OCR1B
+#endif
+
+#ifdef B7_AUDIO
+    #define TIMER_1_PERIOD     ICR1
+    #define TIMER_1_DUTY_CYCLE OCR1C
+#endif
+
 
 // -----------------------------------------------------------------------------
 
@@ -97,7 +127,7 @@ bool     playing_note = false;
 float    note_frequency = 0;
 float    note_length = 0;
 uint8_t  note_tempo = TEMPO_DEFAULT;
-float    note_timbre = TIMBRE_DEFAULT;
+float    note_timbre[NUMBER_OF_TIMERS] = {TIMBRE_DEFAULT};
 uint16_t note_position = 0;
 float (* notes_pointer)[][2];
 uint16_t notes_count;
@@ -119,8 +149,8 @@ static bool audio_initialized = false;
 
 audio_config_t audio_config;
 
-uint16_t envelope_index = 0;
+uint16_t envelope_index[NUMBER_OF_TIMERS] = {0};
-bool glissando = true;
+bool glissando[NUMBER_OF_TIMERS] = {true};
 
 #ifndef STARTUP_SONG
     #define STARTUP_SONG SONG(STARTUP_SOUND)
@@ -163,11 +193,25 @@ void audio_init()
         //    PORTB &= ~_BV(PORTB5);
         #endif
 
+        #ifdef B6_AUDIO
+            DDRB |= _BV(PORTB6);
+        // #else
+        //     DDRB |= _BV(PORTB6);
+        //     PORTB &= ~_BV(PORTB6);
+        #endif
+
+        #ifdef B7_AUDIO
+            DDRB |= _BV(PORTB7);
+        // #else
+        //     DDRB |= _BV(PORTB7);
+        //     PORTB &= ~_BV(PORTB7);
+        #endif
+
         #ifdef C6_AUDIO
             DISABLE_AUDIO_COUNTER_3_ISR;
         #endif
         
-        #ifdef B5_AUDIO
+        #ifdef B_AUDIO
             DISABLE_AUDIO_COUNTER_1_ISR;
         #endif
 
@@ -179,14 +223,17 @@ void audio_init()
         #ifdef C6_AUDIO
             TCCR3A = (0 << COM3A1) | (0 << COM3A0) | (1 << WGM31) | (0 << WGM30);
             TCCR3B = (1 << WGM33)  | (1 << WGM32)  | (0 << CS32)  | (1 << CS31) | (0 << CS30);
+
+            TIMER_3_PERIOD = (uint16_t)(((float)F_CPU) / (440 * CPU_PRESCALER));
+            TIMER_3_DUTY_CYCLE = (uint16_t)((((float)F_CPU) / (440 * CPU_PRESCALER)) * note_timbre[TIMER_3_INDEX]);
         #endif
 
-        #ifdef B5_AUDIO
+        #ifdef B_AUDIO
             TCCR1A = (0 << COM1A1) | (0 << COM1A0) | (1 << WGM11) | (0 << WGM10);
             TCCR1B = (1 << WGM13)  | (1 << WGM12)  | (0 << CS12)  | (1 << CS11) | (0 << CS10);
 
             TIMER_1_PERIOD = (uint16_t)(((float)F_CPU) / (440 * CPU_PRESCALER));
-            TIMER_1_DUTY_CYCLE = (uint16_t)((((float)F_CPU) / (440 * CPU_PRESCALER)) * note_timbre);
+            TIMER_1_DUTY_CYCLE = (uint16_t)((((float)F_CPU) / (440 * CPU_PRESCALER)) * note_timbre[TIMER_1_INDEX]);
         #endif
 
         audio_initialized = true;
@@ -213,7 +260,7 @@ void stop_all_notes()
         DISABLE_AUDIO_COUNTER_3_OUTPUT;
     #endif
 
-    #ifdef B5_AUDIO
+    #ifdef B_AUDIO
         DISABLE_AUDIO_COUNTER_1_ISR;
         DISABLE_AUDIO_COUNTER_1_OUTPUT;
     #endif
@@ -258,12 +305,18 @@ void stop_note(float freq)
         if (voice_place >= voices) {
             voice_place = 0;
         }
+        if (voices == 1) {
+            #if defined(C6_AUDIO) && defined(B_AUDIO)
+                DISABLE_AUDIO_COUNTER_1_ISR;
+                DISABLE_AUDIO_COUNTER_1_OUTPUT;
+            #endif
+        }
         if (voices == 0) {
             #ifdef C6_AUDIO
                 DISABLE_AUDIO_COUNTER_3_ISR;
                 DISABLE_AUDIO_COUNTER_3_OUTPUT;
             #endif
-            #ifdef B5_AUDIO
+            #ifdef B_AUDIO
                 DISABLE_AUDIO_COUNTER_1_ISR;
                 DISABLE_AUDIO_COUNTER_1_OUTPUT;
             #endif
@@ -303,11 +356,11 @@ ISR(TIMER3_COMPA_vect)
     if (playing_note) {
         if (voices > 0) {
 
-            #ifdef B5_AUDIO
+            #ifdef B_AUDIO
             float freq_alt = 0;
                 if (voices > 1) {
                     if (polyphony_rate == 0) {
-                        if (glissando) {
+                        if (glissando[TIMER_1_INDEX] && NUMBER_OF_TIMERS == 1) {
                             if (frequency_alt != 0 && frequency_alt < frequencies[voices - 2] && frequency_alt < frequencies[voices - 2] * pow(2, -440/frequencies[voices - 2]/12/2)) {
                                 frequency_alt = frequency_alt * pow(2, 440/frequency_alt/12/2);
                             } else if (frequency_alt != 0 && frequency_alt > frequencies[voices - 2] && frequency_alt > frequencies[voices - 2] * pow(2, 440/frequencies[voices - 2]/12/2)) {
@@ -330,18 +383,18 @@ ISR(TIMER3_COMPA_vect)
                         #endif
                     }
 
-                    if (envelope_index < 65535) {
+                    if (envelope_index[TIMER_1_INDEX] < 65535) {
-                        envelope_index++;
+                        envelope_index[TIMER_1_INDEX]++;
                     }
 
-                    freq_alt = voice_envelope(freq_alt);
+                    freq_alt = voice_envelope(freq_alt,TIMER_1_INDEX);
 
                     if (freq_alt < 30.517578125) {
                         freq_alt = 30.52;
                     }
 
                     TIMER_1_PERIOD = (uint16_t)(((float)F_CPU) / (freq_alt * CPU_PRESCALER));
-                    TIMER_1_DUTY_CYCLE = (uint16_t)((((float)F_CPU) / (freq_alt * CPU_PRESCALER)) * note_timbre);
+                    TIMER_1_DUTY_CYCLE = (uint16_t)((((float)F_CPU) / (freq_alt * CPU_PRESCALER)) * note_timbre[TIMER_1_INDEX]);
                 }
             #endif
 
@@ -364,7 +417,7 @@ ISR(TIMER3_COMPA_vect)
                     freq = frequencies[voice_place];
                 #endif
             } else {
-                if (glissando) {
+                if (glissando[TIMER_3_INDEX] && NUMBER_OF_TIMERS == 1) {
                     if (frequency != 0 && frequency < frequencies[voices - 1] && frequency < frequencies[voices - 1] * pow(2, -440/frequencies[voices - 1]/12/2)) {
                         frequency = frequency * pow(2, 440/frequency/12/2);
                     } else if (frequency != 0 && frequency > frequencies[voices - 1] && frequency > frequencies[voices - 1] * pow(2, 440/frequencies[voices - 1]/12/2)) {
@@ -387,18 +440,18 @@ ISR(TIMER3_COMPA_vect)
                 #endif
             }
 
-            if (envelope_index < 65535) {
+            if (envelope_index[TIMER_3_INDEX] < 65535) {
-                envelope_index++;
+                envelope_index[TIMER_3_INDEX]++;
             }
 
-            freq = voice_envelope(freq);
+            freq = voice_envelope(freq, TIMER_3_INDEX);
 
             if (freq < 30.517578125) {
                 freq = 30.52;
             }
 
             TIMER_3_PERIOD = (uint16_t)(((float)F_CPU) / (freq * CPU_PRESCALER));
-            TIMER_3_DUTY_CYCLE = (uint16_t)((((float)F_CPU) / (freq * CPU_PRESCALER)) * note_timbre);
+            TIMER_3_DUTY_CYCLE = (uint16_t)((((float)F_CPU) / (freq * CPU_PRESCALER)) * note_timbre[TIMER_3_INDEX]);
         }
     }
 
@@ -414,13 +467,13 @@ ISR(TIMER3_COMPA_vect)
                     freq = note_frequency;
             #endif
 
-            if (envelope_index < 65535) {
+            if (envelope_index[TIMER_3_INDEX] < 65535) {
-                envelope_index++;
+                envelope_index[TIMER_3_INDEX]++;
             }
-            freq = voice_envelope(freq);
+            freq = voice_envelope(freq, TIMER_3_INDEX);
 
             TIMER_3_PERIOD = (uint16_t)(((float)F_CPU) / (freq * CPU_PRESCALER));
-            TIMER_3_DUTY_CYCLE = (uint16_t)((((float)F_CPU) / (freq * CPU_PRESCALER)) * note_timbre);
+            TIMER_3_DUTY_CYCLE = (uint16_t)((((float)F_CPU) / (freq * CPU_PRESCALER)) * note_timbre[TIMER_3_INDEX]);
         } else {
             TIMER_3_PERIOD = 0;
             TIMER_3_DUTY_CYCLE = 0;
@@ -461,7 +514,7 @@ ISR(TIMER3_COMPA_vect)
                 }
             } else {
                 note_resting = false;
-                envelope_index = 0;
+                envelope_index[TIMER_3_INDEX] = 0;
                 note_frequency = (*notes_pointer)[current_note][0];
                 note_length = ((*notes_pointer)[current_note][1] / 4) * (((float)note_tempo) / 100);
             }
@@ -477,10 +530,16 @@ ISR(TIMER3_COMPA_vect)
 }
 #endif
 
+#ifdef B_AUDIO
 #ifdef B5_AUDIO
 ISR(TIMER1_COMPA_vect)
+#elif defined(B6_AUDIO)
+ISR(TIMER1_COMPB_vect)
+#elif defined(B7_AUDIO)
+ISR(TIMER1_COMPC_vect)
+#endif
 {
-    #if defined(B5_AUDIO) && !defined(C6_AUDIO)
+    #if defined(B_AUDIO) && !defined(C6_AUDIO)
     float freq = 0;
 
     if (playing_note) {
@@ -504,7 +563,7 @@ ISR(TIMER1_COMPA_vect)
                     freq = frequencies[voice_place];
                 #endif
             } else {
-                if (glissando) {
+                if (glissando[TIMER_1_INDEX] && NUMBER_OF_TIMERS == 1) {
                     if (frequency != 0 && frequency < frequencies[voices - 1] && frequency < frequencies[voices - 1] * pow(2, -440/frequencies[voices - 1]/12/2)) {
                         frequency = frequency * pow(2, 440/frequency/12/2);
                     } else if (frequency != 0 && frequency > frequencies[voices - 1] && frequency > frequencies[voices - 1] * pow(2, 440/frequencies[voices - 1]/12/2)) {
@@ -527,18 +586,18 @@ ISR(TIMER1_COMPA_vect)
                 #endif
             }
 
-            if (envelope_index < 65535) {
+            if (envelope_index[TIMER_1_INDEX] < 65535) {
-                envelope_index++;
+                envelope_index[TIMER_1_INDEX]++;
             }
 
-            freq = voice_envelope(freq);
+            freq = voice_envelope(freq, TIMER_1_INDEX);
 
             if (freq < 30.517578125) {
                 freq = 30.52;
             }
 
             TIMER_1_PERIOD = (uint16_t)(((float)F_CPU) / (freq * CPU_PRESCALER));
-            TIMER_1_DUTY_CYCLE = (uint16_t)((((float)F_CPU) / (freq * CPU_PRESCALER)) * note_timbre);
+            TIMER_1_DUTY_CYCLE = (uint16_t)((((float)F_CPU) / (freq * CPU_PRESCALER)) * note_timbre[TIMER_1_INDEX]);
         }
     }
 
@@ -554,13 +613,13 @@ ISR(TIMER1_COMPA_vect)
                     freq = note_frequency;
             #endif
 
-            if (envelope_index < 65535) {
+            if (envelope_index[TIMER_1_INDEX] < 65535) {
-                envelope_index++;
+                envelope_index[TIMER_1_INDEX]++;
             }
-            freq = voice_envelope(freq);
+            freq = voice_envelope(freq, TIMER_1_INDEX);
 
             TIMER_1_PERIOD = (uint16_t)(((float)F_CPU) / (freq * CPU_PRESCALER));
-            TIMER_1_DUTY_CYCLE = (uint16_t)((((float)F_CPU) / (freq * CPU_PRESCALER)) * note_timbre);
+            TIMER_1_DUTY_CYCLE = (uint16_t)((((float)F_CPU) / (freq * CPU_PRESCALER)) * note_timbre[TIMER_1_INDEX]);
         } else {
             TIMER_1_PERIOD = 0;
             TIMER_1_DUTY_CYCLE = 0;
@@ -601,7 +660,7 @@ ISR(TIMER1_COMPA_vect)
                 }
             } else {
                 note_resting = false;
-                envelope_index = 0;
+                envelope_index[TIMER_1_INDEX] = 0;
                 note_frequency = (*notes_pointer)[current_note][0];
                 note_length = ((*notes_pointer)[current_note][1] / 4) * (((float)note_tempo) / 100);
             }
@@ -630,7 +689,7 @@ void play_note(float freq, int vol) {
         #ifdef C6_AUDIO
             DISABLE_AUDIO_COUNTER_3_ISR;
         #endif
-        #ifdef B5_AUDIO
+        #ifdef B_AUDIO
             DISABLE_AUDIO_COUNTER_1_ISR;
         #endif
 
@@ -640,7 +699,6 @@ void play_note(float freq, int vol) {
 
         playing_note = true;
 
-        envelope_index = 0;
 
         if (freq > 0) {
             frequencies[voices] = freq;
@@ -652,16 +710,23 @@ void play_note(float freq, int vol) {
             ENABLE_AUDIO_COUNTER_3_ISR;
             ENABLE_AUDIO_COUNTER_3_OUTPUT;
         #endif
-        #ifdef B5_AUDIO
+
+        #ifdef B_AUDIO
             #ifdef C6_AUDIO
             if (voices > 1) {
+                envelope_index[TIMER_3_INDEX] = 0;
                 ENABLE_AUDIO_COUNTER_1_ISR;
                 ENABLE_AUDIO_COUNTER_1_OUTPUT;
+            } else {
+                envelope_index[TIMER_3_INDEX] = 0;
             }
             #else
+            envelope_index[TIMER_1_INDEX] = 0;
             ENABLE_AUDIO_COUNTER_1_ISR;
             ENABLE_AUDIO_COUNTER_1_OUTPUT;
             #endif
+        #else
+            envelope_index[TIMER_3_INDEX] = 0;
         #endif
     }
 
@@ -679,7 +744,7 @@ void play_notes(float (*np)[][2], uint16_t n_count, bool n_repeat)
         #ifdef C6_AUDIO
             DISABLE_AUDIO_COUNTER_3_ISR;
         #endif
-        #ifdef B5_AUDIO
+        #ifdef B_AUDIO
             DISABLE_AUDIO_COUNTER_1_ISR;
         #endif
 
@@ -705,7 +770,7 @@ void play_notes(float (*np)[][2], uint16_t n_count, bool n_repeat)
             ENABLE_AUDIO_COUNTER_3_ISR;
             ENABLE_AUDIO_COUNTER_3_OUTPUT;
         #endif
-        #ifdef B5_AUDIO
+        #ifdef B_AUDIO
             #ifndef C6_AUDIO
             ENABLE_AUDIO_COUNTER_1_ISR;
             ENABLE_AUDIO_COUNTER_1_OUTPUT;
@@ -803,8 +868,8 @@ void decrease_polyphony_rate(float change) {
 
 // Timbre function
 
-void set_timbre(float timbre) {
+void set_timbre(float timbre, uint8_t timer_index) {
-    note_timbre = timbre;
+    note_timbre[timer_index] = timbre;
 }
 
 // Tempo functions

quantum/audio/audio.h

@@ -36,6 +36,42 @@
 // Enable vibrato strength/amplitude - slows down ISR too much
 // #define VIBRATO_STRENGTH_ENABLE
 
+#if defined(__AVR__)
+
+// avr
+
+#ifdef B_AUDIO
+#error Please define B5_AUDIO, B6_AUDIO, or B7_AUDIO instead
+#endif
+
+#if defined(B5_AUDIO) || defined(B6_AUDIO) || defined(B7_AUDIO)
+    #define B_AUDIO
+#endif
+
+#if defined(C6_AUDIO) && defined (B_AUDIO)
+  #define NUMBER_OF_TIMERS 2
+#elif defined(C6_AUDIO)
+  #define NUMBER_OF_TIMERS 1
+#elif defined(B_AUDIO)
+  #define NUMBER_OF_TIMERS 1
+#else
+  #define NUMBER_OF_TIMERS 0
+#endif
+
+#define TIMER_1_INDEX 0
+#define TIMER_3_INDEX 1 
+
+#else
+
+// chibios
+
+#define NUMBER_OF_TIMERS 2
+
+#define TIMER_6_INDEX 0
+#define TIMER_7_INDEX 1 
+
+#endif
+
 typedef union {
     uint8_t raw;
     struct {
@@ -75,7 +111,7 @@ void disable_polyphony(void);
 void increase_polyphony_rate(float change);
 void decrease_polyphony_rate(float change);
 
-void set_timbre(float timbre);
+void set_timbre(float timbre, uint8_t timer_index);
 void set_tempo(uint8_t tempo);
 
 void increase_tempo(uint8_t tempo_change);

quantum/audio/audio_arm.c

@@ -18,7 +18,6 @@
 #include "ch.h"
 #include "hal.h"
 
-#include <stdio.h>
 #include <string.h>
 #include "print.h"
 #include "keymap.h"
@@ -48,7 +47,7 @@ bool     playing_note = false;
 float    note_frequency = 0;
 float    note_length = 0;
 uint8_t  note_tempo = TEMPO_DEFAULT;
-float    note_timbre = TIMBRE_DEFAULT;
+float    note_timbre[NUMBER_OF_TIMERS] = {TIMBRE_DEFAULT};
 uint16_t note_position = 0;
 float (* notes_pointer)[][2];
 uint16_t notes_count;
@@ -70,31 +69,56 @@ static bool audio_initialized = false;
 
 audio_config_t audio_config;
 
-uint16_t envelope_index = 0;
+uint16_t envelope_index[NUMBER_OF_TIMERS] = {0};
-bool glissando = true;
+bool glissando[NUMBER_OF_TIMERS] = {true};
 
 #ifndef STARTUP_SONG
     #define STARTUP_SONG SONG(STARTUP_SOUND)
 #endif
 float startup_song[][2] = STARTUP_SONG;
 
-static void gpt_cb6(GPTDriver *gptp);
-static void gpt_cb7(GPTDriver *gptp);
 static void gpt_cb8(GPTDriver *gptp);
 
+#define DAC_BUFFER_SIZE 360
+
+#define START_CHANNEL_1() gptStart(&GPTD6, &gpt6cfg1); \
+    gptStartContinuous(&GPTD6, 2U)
+#define START_CHANNEL_2() gptStart(&GPTD7, &gpt7cfg1); \
+    gptStartContinuous(&GPTD7, 2U)
+#define STOP_CHANNEL_1() gptStopTimer(&GPTD6)
+#define STOP_CHANNEL_2() gptStopTimer(&GPTD7)
+#define RESTART_CHANNEL_1() STOP_CHANNEL_1(); \
+    START_CHANNEL_1()
+#define RESTART_CHANNEL_2() STOP_CHANNEL_1(); \
+    START_CHANNEL_1()
+#define UPDATE_CHANNEL_1_FREQ(freq) gpt6cfg1.frequency = freq * DAC_BUFFER_SIZE; \
+    RESTART_CHANNEL_1()
+#define UPDATE_CHANNEL_2_FREQ(freq) gpt7cfg1.frequency = freq * DAC_BUFFER_SIZE; \
+    RESTART_CHANNEL_2()
+#define GET_CHANNEL_1_FREQ gpt6cfg1.frequency
+#define GET_CHANNEL_2_FREQ gpt7cfg1.frequency
+
+
 /*
  * GPT6 configuration.
  */
+// static const GPTConfig gpt6cfg1 = {
+//   .frequency    = 1000000U,
+//   .callback     = NULL,
+//   .cr2          = TIM_CR2_MMS_1,    /* MMS = 010 = TRGO on Update Event.    */
+//   .dier         = 0U
+// };
+
 GPTConfig gpt6cfg1 = {
-  .frequency    = 440,
+  .frequency    = 440U*DAC_BUFFER_SIZE,
-  .callback     = gpt_cb6,
+  .callback     = NULL,
   .cr2          = TIM_CR2_MMS_1,    /* MMS = 010 = TRGO on Update Event.    */
   .dier         = 0U
 };
 
 GPTConfig gpt7cfg1 = {
-  .frequency    = 440,
+  .frequency    = 440U*DAC_BUFFER_SIZE,
-  .callback     = gpt_cb7,
+  .callback     = NULL,
   .cr2          = TIM_CR2_MMS_1,    /* MMS = 010 = TRGO on Update Event.    */
   .dier         = 0U
 };
@@ -106,15 +130,122 @@ GPTConfig gpt8cfg1 = {
   .dier         = 0U
 };
 
-static void gpt_cb6(GPTDriver *gptp) {
+
-    palTogglePad(GPIOA, 4);
+/*
+ * DAC test buffer (sine wave).
+ */
+// static const dacsample_t dac_buffer[DAC_BUFFER_SIZE] = {
+//   2047, 2082, 2118, 2154, 2189, 2225, 2260, 2296, 2331, 2367, 2402, 2437,
+//   2472, 2507, 2542, 2576, 2611, 2645, 2679, 2713, 2747, 2780, 2813, 2846,
+//   2879, 2912, 2944, 2976, 3008, 3039, 3070, 3101, 3131, 3161, 3191, 3221,
+//   3250, 3278, 3307, 3335, 3362, 3389, 3416, 3443, 3468, 3494, 3519, 3544,
+//   3568, 3591, 3615, 3637, 3660, 3681, 3703, 3723, 3744, 3763, 3782, 3801,
+//   3819, 3837, 3854, 3870, 3886, 3902, 3917, 3931, 3944, 3958, 3970, 3982,
+//   3993, 4004, 4014, 4024, 4033, 4041, 4049, 4056, 4062, 4068, 4074, 4078,
+//   4082, 4086, 4089, 4091, 4092, 4093, 4094, 4093, 4092, 4091, 4089, 4086,
+//   4082, 4078, 4074, 4068, 4062, 4056, 4049, 4041, 4033, 4024, 4014, 4004,
+//   3993, 3982, 3970, 3958, 3944, 3931, 3917, 3902, 3886, 3870, 3854, 3837,
+//   3819, 3801, 3782, 3763, 3744, 3723, 3703, 3681, 3660, 3637, 3615, 3591,
+//   3568, 3544, 3519, 3494, 3468, 3443, 3416, 3389, 3362, 3335, 3307, 3278,
+//   3250, 3221, 3191, 3161, 3131, 3101, 3070, 3039, 3008, 2976, 2944, 2912,
+//   2879, 2846, 2813, 2780, 2747, 2713, 2679, 2645, 2611, 2576, 2542, 2507,
+//   2472, 2437, 2402, 2367, 2331, 2296, 2260, 2225, 2189, 2154, 2118, 2082,
+//   2047, 2012, 1976, 1940, 1905, 1869, 1834, 1798, 1763, 1727, 1692, 1657,
+//   1622, 1587, 1552, 1518, 1483, 1449, 1415, 1381, 1347, 1314, 1281, 1248,
+//   1215, 1182, 1150, 1118, 1086, 1055, 1024,  993,  963,  933,  903,  873,
+//    844,  816,  787,  759,  732,  705,  678,  651,  626,  600,  575,  550,
+//    526,  503,  479,  457,  434,  413,  391,  371,  350,  331,  312,  293,
+//    275,  257,  240,  224,  208,  192,  177,  163,  150,  136,  124,  112,
+//    101,   90,   80,   70,   61,   53,   45,   38,   32,   26,   20,   16,
+//     12,    8,    5,    3,    2,    1,    0,    1,    2,    3,    5,    8,
+//     12,   16,   20,   26,   32,   38,   45,   53,   61,   70,   80,   90,
+//    101,  112,  124,  136,  150,  163,  177,  192,  208,  224,  240,  257,
+//    275,  293,  312,  331,  350,  371,  391,  413,  434,  457,  479,  503,
+//    526,  550,  575,  600,  626,  651,  678,  705,  732,  759,  787,  816,
+//    844,  873,  903,  933,  963,  993, 1024, 1055, 1086, 1118, 1150, 1182,
+//   1215, 1248, 1281, 1314, 1347, 1381, 1415, 1449, 1483, 1518, 1552, 1587,
+//   1622, 1657, 1692, 1727, 1763, 1798, 1834, 1869, 1905, 1940, 1976, 2012
+// };
+
+// squarewave
+static const dacsample_t dac_buffer[DAC_BUFFER_SIZE] = {
+  2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
+  2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
+  2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
+  2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
+  2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
+  2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
+  2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
+  2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
+  2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
+  2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
+  2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
+  2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
+  2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
+  2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
+  2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
+
+  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,  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
+};
+
+/*
+ * DAC streaming callback.
+ */
+size_t nx = 0, ny = 0, nz = 0;
+static void end_cb1(DACDriver *dacp, const dacsample_t *buffer, size_t n) {
+
+  (void)dacp;
+
+  nz++;
+  if (dac_buffer == buffer) {
+    nx += n;
+  }
+  else {
+    ny += n;
+  }
+
+  if ((nz % 1000) == 0) {
+    // palTogglePad(GPIOD, GPIOD_LED3);
+  }
 }
 
+/*
+ * DAC error callback.
+ */
+static void error_cb1(DACDriver *dacp, dacerror_t err) {
 
-static void gpt_cb7(GPTDriver *gptp) {
+  (void)dacp;
-    palTogglePad(GPIOA, 5);
+  (void)err;
+
+  chSysHalt("DAC failure");
 }
 
+static const DACConfig dac1cfg1 = {
+  .init         = 2047U,
+  .datamode     = DAC_DHRM_12BIT_RIGHT
+};
+
+static const DACConversionGroup dacgrpcfg1 = {
+  .num_channels = 1U,
+  .end_cb       = end_cb1,
+  .error_cb     = error_cb1,
+  .trigger      = DAC_TRG(0)
+};
+
 void audio_init()
 {
 
@@ -129,8 +260,27 @@ void audio_init()
     // audio_config.raw = eeconfig_read_audio();
     audio_config.enable = true;
 
-    palSetPadMode(GPIOA, 4, PAL_MODE_OUTPUT_PUSHPULL);
+  /*
-    palSetPadMode(GPIOA, 5, PAL_MODE_OUTPUT_PUSHPULL);
+   * Starting DAC1 driver, setting up the output pin as analog as suggested
+   * by the Reference Manual.
+   */
+  palSetPadMode(GPIOA, 4, PAL_MODE_INPUT_ANALOG);
+  palSetPadMode(GPIOA, 5, PAL_MODE_INPUT_ANALOG);
+  dacStart(&DACD1, &dac1cfg1);
+
+  /*
+   * Starting GPT6 driver, it is used for triggering the DAC.
+   */
+  START_CHANNEL_1();
+  START_CHANNEL_2();
+
+  /*
+   * Starting a continuous conversion.
+   */
+  dacStartConversion(&DACD1, &dacgrpcfg1,
+                     (dacsample_t *)dac_buffer, DAC_BUFFER_SIZE);
+  // gptStartContinuous(&GPTD6, 2U);
+
 
     audio_initialized = true;
 
@@ -194,8 +344,8 @@ void stop_note(float freq)
             voice_place = 0;
         }
         if (voices == 0) {
-            gptStopTimer(&GPTD6);
+            STOP_CHANNEL_1();
-            gptStopTimer(&GPTD7);
+            STOP_CHANNEL_2();
             gptStopTimer(&GPTD8);
             frequency = 0;
             frequency_alt = 0;
@@ -225,20 +375,6 @@ float vibrato(float average_freq) {
 
 #endif
 
-static void restart_gpt6(void) {
-    // gptStopTimer(&GPTD6);
-
-    gptStart(&GPTD6, &gpt6cfg1);
-    gptStartContinuous(&GPTD6, 2U);
-}
-
-static void restart_gpt7(void) {
-    // gptStopTimer(&GPTD7);
-
-    gptStart(&GPTD7, &gpt7cfg1);
-    gptStartContinuous(&GPTD7, 2U);
-}
-
 static void gpt_cb8(GPTDriver *gptp) {
     float freq;
 
@@ -248,7 +384,7 @@ static void gpt_cb8(GPTDriver *gptp) {
             float freq_alt = 0;
                 if (voices > 1) {
                     if (polyphony_rate == 0) {
-                        if (glissando) {
+                        if (glissando[TIMER_6_INDEX]) {
                             if (frequency_alt != 0 && frequency_alt < frequencies[voices - 2] && frequency_alt < frequencies[voices - 2] * pow(2, -440/frequencies[voices - 2]/12/2)) {
                                 frequency_alt = frequency_alt * pow(2, 440/frequency_alt/12/2);
                             } else if (frequency_alt != 0 && frequency_alt > frequencies[voices - 2] && frequency_alt > frequencies[voices - 2] * pow(2, 440/frequencies[voices - 2]/12/2)) {
@@ -271,23 +407,22 @@ static void gpt_cb8(GPTDriver *gptp) {
                         #endif
                     }
 
-                    if (envelope_index < 65535) {
+                    if (envelope_index[TIMER_6_INDEX] < 65535) {
-                        envelope_index++;
+                        envelope_index[TIMER_6_INDEX]++;
                     }
 
-                    freq_alt = voice_envelope(freq_alt);
+                    freq_alt = voice_envelope(freq_alt, TIMER_6_INDEX);
 
                     if (freq_alt < 30.517578125) {
                         freq_alt = 30.52;
                     }
 
-                    if (gpt6cfg1.frequency != (uint16_t)freq_alt) {
+                    if (GET_CHANNEL_1_FREQ != (uint16_t)freq_alt) {
-                        gpt6cfg1.frequency = freq_alt;
+                        UPDATE_CHANNEL_1_FREQ(freq_alt);
-                        restart_gpt6();
                     }
                     //note_timbre;
                 } else {
-                    // gptStopTimer(&GPTD6);
+                    STOP_CHANNEL_1();
                 }
 
             if (polyphony_rate > 0) {
@@ -309,7 +444,7 @@ static void gpt_cb8(GPTDriver *gptp) {
                     freq = frequencies[voice_place];
                 #endif
             } else {
-                if (glissando) {
+                if (glissando[TIMER_7_INDEX]) {
                     if (frequency != 0 && frequency < frequencies[voices - 1] && frequency < frequencies[voices - 1] * pow(2, -440/frequencies[voices - 1]/12/2)) {
                         frequency = frequency * pow(2, 440/frequency/12/2);
                     } else if (frequency != 0 && frequency > frequencies[voices - 1] && frequency > frequencies[voices - 1] * pow(2, 440/frequencies[voices - 1]/12/2)) {
@@ -332,20 +467,19 @@ static void gpt_cb8(GPTDriver *gptp) {
                 #endif
             }
 
-            if (envelope_index < 65535) {
+            if (envelope_index[TIMER_7_INDEX] < 65535) {
-                envelope_index++;
+                envelope_index[TIMER_7_INDEX]++;
             }
 
-            freq = voice_envelope(freq);
+            freq = voice_envelope(freq, TIMER_7_INDEX);
 
             if (freq < 30.517578125) {
                 freq = 30.52;
             }
 
 
-            if (gpt7cfg1.frequency != (uint16_t)freq) {
+            if (GET_CHANNEL_2_FREQ != (uint16_t)freq) {
-                gpt7cfg1.frequency = freq;
+                UPDATE_CHANNEL_2_FREQ(freq);
-                restart_gpt7();
             }
             //note_timbre;
         } else {
@@ -365,17 +499,15 @@ static void gpt_cb8(GPTDriver *gptp) {
                     freq = note_frequency;
             #endif
 
-            if (envelope_index < 65535) {
+            if (envelope_index[TIMER_6_INDEX] < 65535) {
-                envelope_index++;
+                envelope_index[TIMER_6_INDEX]++;
             }
-            freq = voice_envelope(freq);
+            freq = voice_envelope(freq, TIMER_6_INDEX);
 
 
-            if (gpt6cfg1.frequency != (uint16_t)freq) {
+            if (GET_CHANNEL_1_FREQ != (uint16_t)freq) {
-                gpt6cfg1.frequency = freq;
+                UPDATE_CHANNEL_1_FREQ(freq);
-                restart_gpt6();
+                UPDATE_CHANNEL_2_FREQ(freq);
-                gpt7cfg1.frequency = freq;
-                restart_gpt7();
             }
             //note_timbre;
         } else {
@@ -385,7 +517,7 @@ static void gpt_cb8(GPTDriver *gptp) {
 
         note_position++;
         bool end_of_note = false;
-        if (gpt6cfg1.frequency > 0) {
+        if (GET_CHANNEL_1_FREQ > 0) {
             if (!note_resting) 
                 end_of_note = (note_position >= (note_length*16 - 1));
             else
@@ -400,8 +532,8 @@ static void gpt_cb8(GPTDriver *gptp) {
                 if (notes_repeat) {
                     current_note = 0;
                 } else {
-                    gptStopTimer(&GPTD6);
+                    STOP_CHANNEL_1();
-                    gptStopTimer(&GPTD7);
+                    STOP_CHANNEL_2();
                     // gptStopTimer(&GPTD8);
                     playing_notes = false;
                     return;
@@ -419,7 +551,7 @@ static void gpt_cb8(GPTDriver *gptp) {
                 }
             } else {
                 note_resting = false;
-                envelope_index = 0;
+                envelope_index[TIMER_6_INDEX] = 0;
                 note_frequency = (*notes_pointer)[current_note][0];
                 note_length = ((*notes_pointer)[current_note][1] / 4) * (((float)note_tempo) / 100);
             }
@@ -450,7 +582,8 @@ void play_note(float freq, int vol) {
 
         playing_note = true;
 
-        envelope_index = 0;
+        envelope_index[TIMER_6_INDEX] = 0;
+        envelope_index[TIMER_7_INDEX] = 0;
 
         if (freq > 0) {
             frequencies[voices] = freq;
@@ -493,8 +626,8 @@ void play_notes(float (*np)[][2], uint16_t n_count, bool n_repeat)
 
         gptStart(&GPTD8, &gpt8cfg1);
         gptStartContinuous(&GPTD8, 2U);
-        restart_gpt6();
+        RESTART_CHANNEL_1();
-        restart_gpt7();
+        RESTART_CHANNEL_2();
     }
 
 }
@@ -583,8 +716,8 @@ void decrease_polyphony_rate(float change) {
 
 // Timbre function
 
-void set_timbre(float timbre) {
+void set_timbre(float timbre, uint8_t timer_index) {
-    note_timbre = timbre;
+    note_timbre[timer_index] = timbre;
 }
 
 // Tempo functions

quantum/audio/musical_notes.h

@@ -53,127 +53,127 @@
 
 // Note Timbre
 // Changes how the notes sound
-#define TIMBRE_12       0.125
+#define TIMBRE_12       0.125f
-#define TIMBRE_25       0.250
+#define TIMBRE_25       0.250f
-#define TIMBRE_50       0.500
+#define TIMBRE_50       0.500f
-#define TIMBRE_75       0.750
+#define TIMBRE_75       0.750f
 #define TIMBRE_DEFAULT  TIMBRE_50
 
 // Notes - # = Octave
 
-#define NOTE_REST         0.00
+#define NOTE_REST         0.00f
 
 /* These notes are currently bugged
-#define NOTE_C0          16.35
+#define NOTE_C0          16.35f
-#define NOTE_CS0         17.32
+#define NOTE_CS0         17.32f
-#define NOTE_D0          18.35
+#define NOTE_D0          18.35f
-#define NOTE_DS0         19.45
+#define NOTE_DS0         19.45f
-#define NOTE_E0          20.60
+#define NOTE_E0          20.60f
-#define NOTE_F0          21.83
+#define NOTE_F0          21.83f
-#define NOTE_FS0         23.12
+#define NOTE_FS0         23.12f
-#define NOTE_G0          24.50
+#define NOTE_G0          24.50f
-#define NOTE_GS0         25.96
+#define NOTE_GS0         25.96f
-#define NOTE_A0          27.50
+#define NOTE_A0          27.50f
-#define NOTE_AS0         29.14
+#define NOTE_AS0         29.14f
-#define NOTE_B0          30.87
+#define NOTE_B0          30.87f
-#define NOTE_C1          32.70
+#define NOTE_C1          32.70f
-#define NOTE_CS1         34.65
+#define NOTE_CS1         34.65f
-#define NOTE_D1          36.71
+#define NOTE_D1          36.71f
-#define NOTE_DS1         38.89
+#define NOTE_DS1         38.89f
-#define NOTE_E1          41.20
+#define NOTE_E1          41.20f
-#define NOTE_F1          43.65
+#define NOTE_F1          43.65f
-#define NOTE_FS1         46.25
+#define NOTE_FS1         46.25f
-#define NOTE_G1          49.00
+#define NOTE_G1          49.00f
-#define NOTE_GS1         51.91
+#define NOTE_GS1         51.91f
-#define NOTE_A1          55.00
+#define NOTE_A1          55.00f
-#define NOTE_AS1         58.27
+#define NOTE_AS1         58.27f
 */
 
-#define NOTE_B1          61.74
+#define NOTE_B1          61.74f
-#define NOTE_C2          65.41
+#define NOTE_C2          65.41f
-#define NOTE_CS2         69.30
+#define NOTE_CS2         69.30f
-#define NOTE_D2          73.42
+#define NOTE_D2          73.42f
-#define NOTE_DS2         77.78
+#define NOTE_DS2         77.78f
-#define NOTE_E2          82.41
+#define NOTE_E2          82.41f
-#define NOTE_F2          87.31
+#define NOTE_F2          87.31f
-#define NOTE_FS2         92.50
+#define NOTE_FS2         92.50f
-#define NOTE_G2          98.00
+#define NOTE_G2          98.00f
-#define NOTE_GS2        103.83
+#define NOTE_GS2        103.83f
-#define NOTE_A2         110.00
+#define NOTE_A2         110.00f
-#define NOTE_AS2        116.54
+#define NOTE_AS2        116.54f
-#define NOTE_B2         123.47
+#define NOTE_B2         123.47f
-#define NOTE_C3         130.81
+#define NOTE_C3         130.81f
-#define NOTE_CS3        138.59
+#define NOTE_CS3        138.59f
-#define NOTE_D3         146.83
+#define NOTE_D3         146.83f
-#define NOTE_DS3        155.56
+#define NOTE_DS3        155.56f
-#define NOTE_E3         164.81
+#define NOTE_E3         164.81f
-#define NOTE_F3         174.61
+#define NOTE_F3         174.61f
-#define NOTE_FS3        185.00
+#define NOTE_FS3        185.00f
-#define NOTE_G3         196.00
+#define NOTE_G3         196.00f
-#define NOTE_GS3        207.65
+#define NOTE_GS3        207.65f
-#define NOTE_A3         220.00
+#define NOTE_A3         220.00f
-#define NOTE_AS3        233.08
+#define NOTE_AS3        233.08f
-#define NOTE_B3         246.94
+#define NOTE_B3         246.94f
-#define NOTE_C4         261.63
+#define NOTE_C4         261.63f
-#define NOTE_CS4        277.18
+#define NOTE_CS4        277.18f
-#define NOTE_D4         293.66
+#define NOTE_D4         293.66f
-#define NOTE_DS4        311.13
+#define NOTE_DS4        311.13f
-#define NOTE_E4         329.63
+#define NOTE_E4         329.63f
-#define NOTE_F4         349.23
+#define NOTE_F4         349.23f
-#define NOTE_FS4        369.99
+#define NOTE_FS4        369.99f
-#define NOTE_G4         392.00
+#define NOTE_G4         392.00f
-#define NOTE_GS4        415.30
+#define NOTE_GS4        415.30f
-#define NOTE_A4         440.00
+#define NOTE_A4         440.00f
-#define NOTE_AS4        466.16
+#define NOTE_AS4        466.16f
-#define NOTE_B4         493.88
+#define NOTE_B4         493.88f
-#define NOTE_C5         523.25
+#define NOTE_C5         523.25f
-#define NOTE_CS5        554.37
+#define NOTE_CS5        554.37f
-#define NOTE_D5         587.33
+#define NOTE_D5         587.33f
-#define NOTE_DS5        622.25
+#define NOTE_DS5        622.25f
-#define NOTE_E5         659.26
+#define NOTE_E5         659.26f
-#define NOTE_F5         698.46
+#define NOTE_F5         698.46f
-#define NOTE_FS5        739.99
+#define NOTE_FS5        739.99f
-#define NOTE_G5         783.99
+#define NOTE_G5         783.99f
-#define NOTE_GS5        830.61
+#define NOTE_GS5        830.61f
-#define NOTE_A5         880.00
+#define NOTE_A5         880.00f
-#define NOTE_AS5        932.33
+#define NOTE_AS5        932.33f
-#define NOTE_B5         987.77
+#define NOTE_B5         987.77f
-#define NOTE_C6        1046.50
+#define NOTE_C6        1046.50f
-#define NOTE_CS6       1108.73
+#define NOTE_CS6       1108.73f
-#define NOTE_D6        1174.66
+#define NOTE_D6        1174.66f
-#define NOTE_DS6       1244.51
+#define NOTE_DS6       1244.51f
-#define NOTE_E6        1318.51
+#define NOTE_E6        1318.51f
-#define NOTE_F6        1396.91
+#define NOTE_F6        1396.91f
-#define NOTE_FS6       1479.98
+#define NOTE_FS6       1479.98f
-#define NOTE_G6        1567.98
+#define NOTE_G6        1567.98f
-#define NOTE_GS6       1661.22
+#define NOTE_GS6       1661.22f
-#define NOTE_A6        1760.00
+#define NOTE_A6        1760.00f
-#define NOTE_AS6       1864.66
+#define NOTE_AS6       1864.66f
-#define NOTE_B6        1975.53
+#define NOTE_B6        1975.53f
-#define NOTE_C7        2093.00
+#define NOTE_C7        2093.00f
-#define NOTE_CS7       2217.46
+#define NOTE_CS7       2217.46f
-#define NOTE_D7        2349.32
+#define NOTE_D7        2349.32f
-#define NOTE_DS7       2489.02
+#define NOTE_DS7       2489.02f
-#define NOTE_E7        2637.02
+#define NOTE_E7        2637.02f
-#define NOTE_F7        2793.83
+#define NOTE_F7        2793.83f
-#define NOTE_FS7       2959.96
+#define NOTE_FS7       2959.96f
-#define NOTE_G7        3135.96
+#define NOTE_G7        3135.96f
-#define NOTE_GS7       3322.44
+#define NOTE_GS7       3322.44f
-#define NOTE_A7        3520.00
+#define NOTE_A7        3520.00f
-#define NOTE_AS7       3729.31
+#define NOTE_AS7       3729.31f
-#define NOTE_B7        3951.07
+#define NOTE_B7        3951.07f
-#define NOTE_C8        4186.01
+#define NOTE_C8        4186.01f
-#define NOTE_CS8       4434.92
+#define NOTE_CS8       4434.92f
-#define NOTE_D8        4698.64
+#define NOTE_D8        4698.64f
-#define NOTE_DS8       4978.03
+#define NOTE_DS8       4978.03f
-#define NOTE_E8        5274.04
+#define NOTE_E8        5274.04f
-#define NOTE_F8        5587.65
+#define NOTE_F8        5587.65f
-#define NOTE_FS8       5919.91
+#define NOTE_FS8       5919.91f
-#define NOTE_G8        6271.93
+#define NOTE_G8        6271.93f
-#define NOTE_GS8       6644.88
+#define NOTE_GS8       6644.88f
-#define NOTE_A8        7040.00
+#define NOTE_A8        7040.00f
-#define NOTE_AS8       7458.62
+#define NOTE_AS8       7458.62f
-#define NOTE_B8        7902.13
+#define NOTE_B8        7902.13f
 
 // Flat Aliases
 #define NOTE_DF0 NOTE_CS0

quantum/audio/song_list.h

@@ -53,6 +53,24 @@
     E__NOTE(_CS4), E__NOTE(_B4),  QD_NOTE(_AS4), \
     E__NOTE(_AS4), E__NOTE(_AS4), QD_NOTE(_B4),
 
+#define CLUEBOARD_SOUND \
+    HD_NOTE(_C3), HD_NOTE(_D3), HD_NOTE(_E3), HD_NOTE(_F3), HD_NOTE(_G3), HD_NOTE(_A4), HD_NOTE(_B4), HD_NOTE(_C4)
+/*
+    HD_NOTE(_G3), HD_NOTE(_E3), HD_NOTE(_C3), \
+    Q__NOTE(_E3), Q__NOTE(_C3), Q__NOTE(_G3), \
+    Q__NOTE(_E3)
+*/
+/*
+    HD_NOTE(_C3), HD_NOTE(_G3), HD_NOTE(_E3), \
+    Q__NOTE(_G3), Q__NOTE(_E3), Q__NOTE(_G3), \
+    Q__NOTE(_F3)
+*/
+
+#define BASKET_CASE \
+    QD_NOTE(_G3), E__NOTE(_F3), E__NOTE(_E3), Q__NOTE(_F3), M__NOTE(_G3, 8+32), Q__NOTE(_REST), \
+    Q__NOTE(_B4), Q__NOTE(_C4), Q__NOTE(_B4), E__NOTE(_A4), Q__NOTE(_G3), M__NOTE(_G3, 8+32), Q__NOTE(_REST), \
+    Q__NOTE(_B4), Q__NOTE(_C4), Q__NOTE(_B4), E__NOTE(_A4), Q__NOTE(_G3), Q__NOTE(_G3), Q__NOTE(_G3), Q__NOTE(_G3), E__NOTE(_A4), E__NOTE(_C4), QD_NOTE(_B4), HD_NOTE(_B4)
+
 #define STARTUP_SOUND  \
     E__NOTE(_E6),     \
     E__NOTE(_A6),     \

quantum/audio/voices.c

@@ -18,73 +18,91 @@
 #include "stdlib.h"
 
 // these are imported from audio.c
-extern uint16_t envelope_index;
+extern uint16_t envelope_index[NUMBER_OF_TIMERS];
-extern float note_timbre;
+extern float note_timbre[NUMBER_OF_TIMERS];
 extern float polyphony_rate;
-extern bool glissando;
+extern bool glissando[NUMBER_OF_TIMERS];
 
-voice_type voice = default_voice;
+voice_type voice[NUMBER_OF_TIMERS] = {default_voice};
 
-void set_voice(voice_type v) {
+void set_all_voices(voice_type v) {
-    voice = v;
+    for (uint8_t i = 0; i < NUMBER_OF_TIMERS; i++) {
+        voice[i] = v;
+    }
 }
 
-void voice_iterate() {
+void all_voices_iterate(void) {
-    voice = (voice + 1) % number_of_voices;
+    for (uint8_t i = 0; i < NUMBER_OF_TIMERS; i++) {
+        voice[i] = (voice[i] + 1) % number_of_voices;
+    }
 }
 
-void voice_deiterate() {
+void all_voices_deiterate(void) {
-    voice = (voice - 1 + number_of_voices) % number_of_voices;
+    for (uint8_t i = 0; i < NUMBER_OF_TIMERS; i++) {
+        voice[i] = (voice[i] - 1 + number_of_voices) % number_of_voices;
+    }
 }
 
-float voice_envelope(float frequency) {
+void set_voice(voice_type v, uint8_t timer_index) {
-    // envelope_index ranges from 0 to 0xFFFF, which is preserved at 880.0 Hz
+    voice[timer_index] = v;
+}
+
+void voice_iterate(uint8_t timer_index) {
+    voice[timer_index] = (voice[timer_index] + 1) % number_of_voices;
+}
+
+void voice_deiterate(uint8_t timer_index) {
+    voice[timer_index] = (voice[timer_index] - 1 + number_of_voices) % number_of_voices;
+}
+
+float voice_envelope(float frequency, uint8_t timer_index) {
+    // envelope_index[timer_index] ranges from 0 to 0xFFFF, which is preserved at 880.0 Hz
     __attribute__ ((unused))
-    uint16_t compensated_index = (uint16_t)((float)envelope_index * (880.0 / frequency));
+    uint16_t compensated_index = (uint16_t)((float)envelope_index[timer_index] * (880.0 / frequency));
 
-    switch (voice) {
+    switch (voice[timer_index]) {
         case default_voice:
-            glissando = false;
+            glissando[timer_index] = false;
-            note_timbre = TIMBRE_50;
+            note_timbre[timer_index] = TIMBRE_50;
             polyphony_rate = 0;
 	        break;
 
     #ifdef AUDIO_VOICES
 
         case something:
-            glissando = false;
+            glissando[timer_index] = false;
             polyphony_rate = 0;
             switch (compensated_index) {
                 case 0 ... 9:
-                    note_timbre = TIMBRE_12;
+                    note_timbre[timer_index] = TIMBRE_12;
                     break;
 
                 case 10 ... 19:
-                    note_timbre = TIMBRE_25;
+                    note_timbre[timer_index] = TIMBRE_25;
                     break;
 
                 case 20 ... 200:
-                    note_timbre = .125 + .125;
+                    note_timbre[timer_index] = .125 + .125;
                     break;
 
                 default:
-                    note_timbre = .125;
+                    note_timbre[timer_index] = .125;
                     break;
             }
             break;
 
         case drums:
-            glissando = false;
+            glissando[timer_index] = false;
             polyphony_rate = 0;
                 // switch (compensated_index) {
                 //     case 0 ... 10:
-                //         note_timbre = 0.5;
+                //         note_timbre[timer_index] = 0.5;
                 //         break;
                 //     case 11 ... 20:
-                //         note_timbre = 0.5 * (21 - compensated_index) / 10;
+                //         note_timbre[timer_index] = 0.5 * (21 - compensated_index) / 10;
                 //         break;
                 //     default:
-                //         note_timbre = 0;
+                //         note_timbre[timer_index] = 0;
                 //         break;
                 // }
                 // frequency = (rand() % (int)(frequency * 1.2 - frequency)) + (frequency * 0.8);
@@ -95,15 +113,15 @@ float voice_envelope(float frequency) {
 
                 // Bass drum: 60 - 100 Hz
                 frequency = (rand() % (int)(40)) + 60;
-                switch (envelope_index) {
+                switch (envelope_index[timer_index]) {
                     case 0 ... 10:
-                        note_timbre = 0.5;
+                        note_timbre[timer_index] = 0.5;
                         break;
                     case 11 ... 20:
-                        note_timbre = 0.5 * (21 - envelope_index) / 10;
+                        note_timbre[timer_index] = 0.5 * (21 - envelope_index[timer_index]) / 10;
                         break;
                     default:
-                        note_timbre = 0;
+                        note_timbre[timer_index] = 0;
                         break;
                 }
 
@@ -112,15 +130,15 @@ float voice_envelope(float frequency) {
 
                 // Snare drum: 1 - 2 KHz
                 frequency = (rand() % (int)(1000)) + 1000;
-                switch (envelope_index) {
+                switch (envelope_index[timer_index]) {
                     case 0 ... 5:
-                        note_timbre = 0.5;
+                        note_timbre[timer_index] = 0.5;
                         break;
                     case 6 ... 20:
-                        note_timbre = 0.5 * (21 - envelope_index) / 15;
+                        note_timbre[timer_index] = 0.5 * (21 - envelope_index[timer_index]) / 15;
                         break;
                     default:
-                        note_timbre = 0;
+                        note_timbre[timer_index] = 0;
                         break;
                 }
 
@@ -128,15 +146,15 @@ float voice_envelope(float frequency) {
 
                 // Closed Hi-hat: 3 - 5 KHz
                 frequency = (rand() % (int)(2000)) + 3000;
-                switch (envelope_index) {
+                switch (envelope_index[timer_index]) {
                     case 0 ... 15:
-                        note_timbre = 0.5;
+                        note_timbre[timer_index] = 0.5;
                         break;
                     case 16 ... 20:
-                        note_timbre = 0.5 * (21 - envelope_index) / 5;
+                        note_timbre[timer_index] = 0.5 * (21 - envelope_index[timer_index]) / 5;
                         break;
                     default:
-                        note_timbre = 0;
+                        note_timbre[timer_index] = 0;
                         break;
                 }
 
@@ -144,96 +162,96 @@ float voice_envelope(float frequency) {
 
                 // Open Hi-hat: 3 - 5 KHz
                 frequency = (rand() % (int)(2000)) + 3000;
-                switch (envelope_index) {
+                switch (envelope_index[timer_index]) {
                     case 0 ... 35:
-                        note_timbre = 0.5;
+                        note_timbre[timer_index] = 0.5;
                         break;
                     case 36 ... 50:
-                        note_timbre = 0.5 * (51 - envelope_index) / 15;
+                        note_timbre[timer_index] = 0.5 * (51 - envelope_index[timer_index]) / 15;
                         break;
                     default:
-                        note_timbre = 0;
+                        note_timbre[timer_index] = 0;
                         break;
                 }
 
             }
             break;
         case butts_fader:
-            glissando = true;
+            glissando[timer_index] = true;
             polyphony_rate = 0;
             switch (compensated_index) {
                 case 0 ... 9:
                     frequency = frequency / 4;
-                    note_timbre = TIMBRE_12;
+                    note_timbre[timer_index] = TIMBRE_12;
 	                break;
 
                 case 10 ... 19:
                     frequency = frequency / 2;
-                    note_timbre = TIMBRE_12;
+                    note_timbre[timer_index] = TIMBRE_12;
 	                break;
 
                 case 20 ... 200:
-                    note_timbre = .125 - pow(((float)compensated_index - 20) / (200 - 20), 2)*.125;
+                    note_timbre[timer_index] = .125 - pow(((float)compensated_index - 20) / (200 - 20), 2)*.125;
 	                break;
 
                 default:
-                    note_timbre = 0;
+                    note_timbre[timer_index] = 0;
                 	break;
             }
     	    break;
 
-        // case octave_crunch:
+        case octave_crunch:
-        //     polyphony_rate = 0;
+            polyphony_rate = 0;
-        //     switch (compensated_index) {
+            switch (compensated_index) {
-        //         case 0 ... 9:
+                case 0 ... 9:
-        //         case 20 ... 24:
+                case 20 ... 24:
-        //         case 30 ... 32:
+                case 30 ... 32:
-        //             frequency = frequency / 2;
+                    frequency = frequency / 2;
-        //             note_timbre = TIMBRE_12;
+                    note_timbre[timer_index] = TIMBRE_12;
-        //         break;
+                break;
 
-        //         case 10 ... 19:
+                case 10 ... 19:
-        //         case 25 ... 29:
+                case 25 ... 29:
-        //         case 33 ... 35:
+                case 33 ... 35:
-        //             frequency = frequency * 2;
+                    frequency = frequency * 2;
-        //             note_timbre = TIMBRE_12;
+                    note_timbre[timer_index] = TIMBRE_12;
-	       //          break;
+	                break;
 
-        //         default:
+                default:
-        //             note_timbre = TIMBRE_12;
+                    note_timbre[timer_index] = TIMBRE_12;
-        //         	break;
+                	break;
-        //     }
+            }
-	       //  break;
+	        break;
 
         case duty_osc:
             // This slows the loop down a substantial amount, so higher notes may freeze
-            glissando = true;
+            glissando[timer_index] = true;
             polyphony_rate = 0;
             switch (compensated_index) {
                 default:
                     #define OCS_SPEED 10
                     #define OCS_AMP   .25
                     // sine wave is slow
-                    // note_timbre = (sin((float)compensated_index/10000*OCS_SPEED) * OCS_AMP / 2) + .5;
+                    // note_timbre[timer_index] = (sin((float)compensated_index/10000*OCS_SPEED) * OCS_AMP / 2) + .5;
                     // triangle wave is a bit faster
-                    note_timbre = (float)abs((compensated_index*OCS_SPEED % 3000) - 1500) * ( OCS_AMP / 1500 ) + (1 - OCS_AMP) / 2;
+                    note_timbre[timer_index] = (float)abs((compensated_index*OCS_SPEED % 3000) - 1500) * ( OCS_AMP / 1500 ) + (1 - OCS_AMP) / 2;
                 	break;
             }
 	        break;
 
         case duty_octave_down:
-            glissando = true;
+            glissando[timer_index] = true;
             polyphony_rate = 0;
-            note_timbre = (envelope_index % 2) * .125 + .375 * 2;
+            note_timbre[timer_index] = (envelope_index[timer_index] % 2) * .125 + .375 * 2;
-            if ((envelope_index % 4) == 0)
+            if ((envelope_index[timer_index] % 4) == 0)
-                note_timbre = 0.5;
+                note_timbre[timer_index] = 0.5;
-            if ((envelope_index % 8) == 0)
+            if ((envelope_index[timer_index] % 8) == 0)
-                note_timbre = 0;
+                note_timbre[timer_index] = 0;
             break;
         case delayed_vibrato:
-            glissando = true;
+            glissando[timer_index] = true;
             polyphony_rate = 0;
-            note_timbre = TIMBRE_50;
+            note_timbre[timer_index] = TIMBRE_50;
             #define VOICE_VIBRATO_DELAY 150
             #define VOICE_VIBRATO_SPEED 50
             switch (compensated_index) {
@@ -246,10 +264,10 @@ float voice_envelope(float frequency) {
             break;
         // case delayed_vibrato_octave:
         //     polyphony_rate = 0;
-        //     if ((envelope_index % 2) == 1) {
+        //     if ((envelope_index[timer_index] % 2) == 1) {
-        //         note_timbre = 0.55;
+        //         note_timbre[timer_index] = 0.55;
         //     } else {
-        //         note_timbre = 0.45;
+        //         note_timbre[timer_index] = 0.45;
         //     }
         //     #define VOICE_VIBRATO_DELAY 150
         //     #define VOICE_VIBRATO_SPEED 50
@@ -262,28 +280,28 @@ float voice_envelope(float frequency) {
         //     }
         //     break;
         // case duty_fifth_down:
-        //     note_timbre = 0.5;
+        //     note_timbre[timer_index] = 0.5;
-        //     if ((envelope_index % 3) == 0)
+        //     if ((envelope_index[timer_index] % 3) == 0)
-        //         note_timbre = 0.75;
+        //         note_timbre[timer_index] = 0.75;
         //     break;
         // case duty_fourth_down:
-        //     note_timbre = 0.0;
+        //     note_timbre[timer_index] = 0.0;
-        //     if ((envelope_index % 12) == 0)
+        //     if ((envelope_index[timer_index] % 12) == 0)
-        //         note_timbre = 0.75;
+        //         note_timbre[timer_index] = 0.75;
-        //     if (((envelope_index % 12) % 4) != 1)
+        //     if (((envelope_index[timer_index] % 12) % 4) != 1)
-        //         note_timbre = 0.75;
+        //         note_timbre[timer_index] = 0.75;
         //     break;
         // case duty_third_down:
-        //     note_timbre = 0.5;
+        //     note_timbre[timer_index] = 0.5;
-        //     if ((envelope_index % 5) == 0)
+        //     if ((envelope_index[timer_index] % 5) == 0)
-        //         note_timbre = 0.75;
+        //         note_timbre[timer_index] = 0.75;
         //     break;
         // case duty_fifth_third_down:
-        //     note_timbre = 0.5;
+        //     note_timbre[timer_index] = 0.5;
-        //     if ((envelope_index % 5) == 0)
+        //     if ((envelope_index[timer_index] % 5) == 0)
-        //         note_timbre = 0.75;
+        //         note_timbre[timer_index] = 0.75;
-        //     if ((envelope_index % 3) == 0)
+        //     if ((envelope_index[timer_index] % 3) == 0)
-        //         note_timbre = 0.25;
+        //         note_timbre[timer_index] = 0.25;
         //     break;
 
     #endif

quantum/audio/voices.h

@@ -24,7 +24,7 @@
 #ifndef VOICES_H
 #define VOICES_H
 
-float voice_envelope(float frequency);
+float voice_envelope(float frequency, uint8_t timer_index);
 
 typedef enum {
     default_voice,
@@ -45,8 +45,12 @@ typedef enum {
     number_of_voices // important that this is last
 } voice_type;
 
-void set_voice(voice_type v);
+void set_all_voices(voice_type v);
-void voice_iterate(void);
+void all_voices_iterate(void);
-void voice_deiterate(void);
+void all_voices_deiterate(void);
+
+void set_voice(voice_type v, uint8_t timer_index);
+void voice_iterate(uint8_t timer_index);
+void voice_deiterate(uint8_t timer_index);
 
 #endif

quantum/process_keycode/process_audio.c

@@ -38,13 +38,13 @@ bool process_audio(uint16_t keycode, keyrecord_t *record) {
     }
 
     if (keycode == MUV_IN && record->event.pressed) {
-        voice_iterate();
+        all_voices_iterate();
         PLAY_SONG(voice_change_song);
         return false;
     }
 
     if (keycode == MUV_DE && record->event.pressed) {
-        voice_deiterate();
+        all_voices_deiterate();
         PLAY_SONG(voice_change_song);
         return false;
     }

quantum/process_keycode/process_music.c

@@ -28,7 +28,7 @@ bool music_activated = false;
 bool midi_activated = false;
 uint8_t music_starting_note = 0x0C;
 int music_offset = 7;
-uint8_t music_mode = MUSIC_MODE_CHROMATIC;
+uint8_t music_mode = MUSIC_MODE_MAJOR;
 
 // music sequencer
 static bool music_sequence_recording = false;

users/gordon/gordon.c

@@ -0,0 +1,275 @@
+#include "gordon.h"
+#include "quantum.h"
+#include "action.h"
+#include "process_keycode/process_tap_dance.h"
+
+#if (__has_include("secret.h"))
+#include "secret.h"
+#else
+const char secret[][64] = {
+  "test1",
+  "test2",
+  "test3",
+  "test4",
+  "test5"
+};
+#endif
+
+
+
+
+void register_hyper (void) { //Helper function to invoke Hyper
+  register_code (KC_LSFT);
+  register_code (KC_LCTL); 
+  register_code (KC_LALT); 
+  register_code (KC_LGUI); 
+}
+void unregister_hyper (void) { //Helper function to invoke Hyper
+  unregister_code (KC_LSFT);
+  unregister_code (KC_LCTL); 
+  unregister_code (KC_LALT); 
+  unregister_code (KC_LGUI); 
+}
+
+void register_ctrl_a (void) {
+  register_code(KC_LCTL);
+  register_code(KC_A);
+}
+
+void unregister_ctrl_a (void) {
+  unregister_code(KC_LCTL);
+  unregister_code(KC_A);
+}
+
+void register_alt_f7 (void) { 
+  register_code (KC_LALT); 
+  register_code (KC_F7);
+}
+
+void unregister_alt_f7 (void) { 
+  unregister_code (KC_LALT); 
+  unregister_code (KC_F7);
+}
+
+void register_shift_f6 (void) { 
+  register_code (KC_LSFT); 
+  register_code (KC_F6);
+}
+
+void unregister_shift_f6 (void) { 
+  unregister_code (KC_LSFT); 
+  unregister_code (KC_F6);
+}
+
+void register_ctrl_shift (void) { 
+  register_code (KC_LSFT); 
+  register_code (KC_LCTRL);
+}
+
+void unregister_ctrl_shift (void) { 
+  unregister_code (KC_LSFT); 
+  unregister_code (KC_LCTRL);
+}
+
+void register_alt_shift (void) { 
+  register_code (KC_LSFT); 
+  register_code (KC_LALT);
+}
+
+void unregister_alt_shift (void) { 
+  unregister_code (KC_LSFT); 
+  unregister_code (KC_LALT);
+}
+
+// To activate SINGLE_HOLD, you will need to hold for 200ms first. 
+// This tap dance favors keys that are used frequently in typing like 'f'
+int cur_dance (qk_tap_dance_state_t *state) {
+  if (state->count == 1) {
+    //If count = 1, and it has been interrupted - it doesn't matter if it is pressed or not: Send SINGLE_TAP
+    if (state->interrupted) {
+      //     if (!state->pressed) return SINGLE_TAP; 
+      //need "permissive hold" here.
+      //     else return SINsGLE_HOLD; 
+      //If the interrupting key is released before the tap-dance key, then it is a single HOLD
+      //However, if the tap-dance key is released first, then it is a single TAP
+      //But how to get access to the state of the interrupting key????
+      return SINGLE_TAP;
+    }
+    else {
+      if (!state->pressed) return SINGLE_TAP;
+      else return SINGLE_HOLD;
+    }
+  }
+  //If count = 2, and it has been interrupted - assume that user is trying to type the letter associated
+  //with single tap.
+  else if (state->count == 2) {
+    if (state->interrupted) return DOUBLE_SINGLE_TAP;
+    else if (state->pressed) return DOUBLE_HOLD;
+    else return DOUBLE_TAP; 
+  } 
+  else if ((state->count == 3) && ((state->interrupted) || (!state->pressed))) return TRIPLE_TAP;
+  else if (state->count == 3) return TRIPLE_HOLD;
+  else return 8; //magic number. At some point this method will expand to work for more presses
+}
+
+//This works well if you want this key to work as a "fast modifier". It favors being held over being tapped.
+int hold_cur_dance (qk_tap_dance_state_t *state) {
+  if (state->count == 1) {
+    if (state->interrupted) {
+      if (!state->pressed) return SINGLE_TAP; 
+      else return SINGLE_HOLD; 
+    }
+    else {
+      if (!state->pressed) return SINGLE_TAP;
+      else return SINGLE_HOLD;
+    }
+  }
+  //If count = 2, and it has been interrupted - assume that user is trying to type the letter associated
+  //with single tap.
+  else if (state->count == 2) {
+    if (state->pressed) return DOUBLE_HOLD;
+    else return DOUBLE_TAP; 
+  } 
+  else if (state->count == 3) {
+    if (!state->pressed) return TRIPLE_TAP;
+    else return TRIPLE_HOLD;
+  }
+  else return 8; //magic number. At some point this method will expand to work for more presses
+}
+
+
+static xtap htap_state = { 
+  .is_press_action = true,
+  .state = 0
+};
+
+void h_finished (qk_tap_dance_state_t *state, void *user_data) {
+  htap_state.state = cur_dance(state);
+  switch (htap_state.state) {
+    case SINGLE_TAP: register_code(KC_H); break;
+    case SINGLE_HOLD: layer_on(8); register_code(KC_LALT); break;
+    case DOUBLE_TAP: layer_invert(8); register_code(KC_LALT); break;
+    // case DOUBLE_HOLD: register_code(KC_LALT);
+    case DOUBLE_SINGLE_TAP: register_code(KC_H);unregister_code(KC_H);register_code(KC_H);
+  }
+}
+
+void h_reset (qk_tap_dance_state_t *state, void *user_data) {
+  switch (htap_state.state) {
+    case SINGLE_TAP: unregister_code(KC_H); break;
+    case SINGLE_HOLD: layer_off(8); unregister_code(KC_LALT); break;
+    case DOUBLE_TAP: unregister_code(KC_LALT);break;
+    // case DOUBLE_HOLD: unregister_code(KC_LALT);
+    case DOUBLE_SINGLE_TAP: unregister_code(KC_H);
+  }
+  htap_state.state = 0;
+}
+
+
+/**************** QUAD FUNCTION FOR TAB ****************/
+// TAB, ALT + SHIFT, TAB TAB, CTRL + SHIFT
+static xtap tab_state = { 
+  .is_press_action = true,
+  .state = 0
+};
+
+void tab_finished (qk_tap_dance_state_t *state, void *user_data) {
+  tab_state.state = cur_dance(state);
+  switch (tab_state.state) {
+    case SINGLE_TAP: register_code(KC_TAB); break;  //send tab on single press
+    case SINGLE_HOLD: register_ctrl_shift(); break;
+    case DOUBLE_HOLD: register_alt_shift(); break; //alt shift on single hold
+    case DOUBLE_TAP: register_code(KC_TAB); unregister_code(KC_TAB); register_code(KC_TAB); break; //tab tab
+    case TRIPLE_TAP: register_code(KC_LSHIFT) ;register_code(KC_ESC); break;
+    case TRIPLE_HOLD: register_code(KC_LSHIFT); register_code(KC_LGUI); break;
+  }
+}   
+
+void tab_reset (qk_tap_dance_state_t *state, void *user_data) {
+  switch (tab_state.state) {
+    case SINGLE_TAP: unregister_code(KC_TAB); break; //unregister tab
+    case DOUBLE_HOLD: unregister_alt_shift(); break; //let go of alt shift
+    case DOUBLE_TAP: unregister_code(KC_TAB); break;
+    case SINGLE_HOLD: unregister_ctrl_shift(); break;
+    case TRIPLE_TAP: unregister_code(KC_LSHIFT); unregister_code(KC_ESC); break;
+    case TRIPLE_HOLD: unregister_code(KC_LSHIFT); unregister_code(KC_LGUI); break;
+  }
+  tab_state.state = 0;
+}
+/**************** QUAD FUNCTION FOR TAB ****************/
+
+//*************** SUPER COMMA *******************//
+// Assumption: we don't care about trying to hit ,, quickly
+//*************** SUPER COMMA *******************//
+static xtap comma_state = { 
+  .is_press_action = true,
+  .state = 0
+};
+
+void comma_finished (qk_tap_dance_state_t *state, void *user_data) {
+  comma_state.state = hold_cur_dance(state); //Use the dance that favors being held
+  switch (comma_state.state) {
+    case SINGLE_TAP: register_code(KC_COMMA); break;  
+    case SINGLE_HOLD: layer_on(1); break; //turn on symbols layer
+    case DOUBLE_TAP: layer_invert(4); break; //toggle numbers layer
+    case DOUBLE_HOLD: layer_on(2); break;
+    case TRIPLE_TAP: register_code(KC_CALCULATOR); break;
+    case TRIPLE_HOLD: layer_on(3);
+  }
+}   
+
+void comma_reset (qk_tap_dance_state_t *state, void *user_data) {
+  switch (comma_state.state) {
+    case SINGLE_TAP: unregister_code(KC_COMMA); break; //unregister comma
+    case SINGLE_HOLD: layer_off(1); break; 
+    case DOUBLE_TAP: ;break;
+    case DOUBLE_HOLD: layer_off(2); break;
+    case TRIPLE_TAP: unregister_code(KC_CALCULATOR); break;
+    case TRIPLE_HOLD: layer_off(3);
+  }
+  comma_state.state = 0;
+}
+//*************** SUPER COMMA *******************//
+//*************** SUPER COMMA *******************//
+
+
+//*************** F3 TAP DANCE *******************//
+//Good example for accessing multiple layers from the same key.
+static xtap S1_state = { 
+  .is_press_action = true,
+  .state = 0
+};
+
+void bt_finished (qk_tap_dance_state_t *state, void *user_data) {
+  S1_state.state = cur_dance(state);
+  switch (S1_state.state) {
+    case SINGLE_TAP: register_code(KC_F3); break;
+    case SINGLE_HOLD: layer_on(4); break;
+    case DOUBLE_TAP: layer_invert(4); break;
+    case DOUBLE_HOLD: layer_on(5); break;
+    case DOUBLE_SINGLE_TAP: layer_invert(4); break;
+  }
+}
+
+void bt_reset (qk_tap_dance_state_t *state, void *user_data) {
+  switch (S1_state.state) {
+    case SINGLE_TAP: unregister_code(KC_F3); break;
+    case SINGLE_HOLD: layer_off(4); break;
+    case DOUBLE_TAP: break; //already inverted. Don't do anything.
+    case DOUBLE_HOLD: layer_off(5); break;
+    case DOUBLE_SINGLE_TAP: break;
+  }
+  S1_state.state = 0;
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case KC_SECRET_1 ... KC_SECRET_5:
+    if (!record->event.pressed) {
+      send_string(secret[keycode - KC_SECRET_1]);
+    }
+    return false;
+    break;
+  }
+  return true;
+}

users/gordon/gordon.h

@@ -0,0 +1,157 @@
+#ifndef GORDON
+#define GORDON
+
+#include "quantum.h"
+#include "process_keycode/process_tap_dance.h"
+
+
+// Fillers to make layering more clear
+#define _______ KC_TRNS
+#define ________ KC_TRNS
+#define _________ KC_TRNS
+#define XXXXXXX KC_NO
+
+// KC codes that are too long
+#define DOLLAR KC_DOLLAR
+#define LSQUIGLY KC_LBRACKET
+#define RSQUIGLY KC_RBRACKET
+#define NUMLOCK KC_NUMLOCK
+#define CAPLOCK KC_CAPSLOCK
+#define BK_SLASH KC_BSLASH
+#define ASTERSK KC_KP_ASTERISK
+ 
+// Navigation
+#define SNAPLEFT  LGUI(KC_LEFT)
+#define SNAPRGHT  LGUI(KC_RIGHT)
+#define SNAPUP    LGUI(KC_UP)
+#define SNAPDOWN  LGUI(KC_DOWN)
+#define PREVTAB   LCTL(LSFT(KC_TAB))
+#define NEXTTAB   LCTL(KC_TAB)
+#define WORKRIGHT LCTL(LGUI(KC_RIGHT))
+#define WORKLEFT  LCTL(LGUI(KC_LEFT))
+
+// KC/modifier hold
+#define CTRL_F   CTL_T(KC_F)
+#define CTRL_J   CTL_T(KC_J)
+#define CTRL_Z   CTL_T(KC_Z)
+#define ALT_V    ALT_T(KC_V)
+#define ALT_M    ALT_T(KC_M)
+#define WIN_G    GUI_T(KC_G)
+#define WIN_H    GUI_T(KC_H)
+#define HYPER_X  ALL_T(KC_X)
+#define HYPE_DOT ALL_T(KC_DOT)
+#define MEH_S    MEH_T(KC_S)
+#define MEH_L    MEH_T(KC_L)
+#define ALT_HOME ALT_T(KC_HOME)
+
+
+// KC/Layer Hold
+#define NAV_E    LT(_NAV,KC_E)
+#define NUMPAD_D LT(_NUMPAD,KC_D)
+#define MOUSE_C  LT(_MOUSE,KC_C)
+#define SYMB_BSP LT(_SYMBOLS,KC_BSPACE)
+#define COL_MOUS LT(_MOUSE,KC_SCOLON)
+#define SPAC_SYM LT(_SYMBOLS,KC_SPACE)
+
+// Double Modifier ONLY hold
+#define ALT_SHFT LSFT(KC_LALT)
+#define CTR_SHFT LSFT(KC_LCTL)
+
+// KC/Double modifier Hold
+#define CTR_SH_W MT(MOD_LCTL|MOD_LSFT,KC_W)
+#define CTR_AL_R MT(MOD_LCTL|MOD_LALT,KC_R)
+
+//MISC
+#define PRINTSCR KC_PSCREEN
+#define CALTDEL LCTL(LALT(KC_DEL))
+#define TSKMGR LCTL(LSFT(KC_ESC))
+
+
+typedef struct {
+  bool is_press_action;
+  int state;
+} xtap;
+
+enum {
+  SINGLE_TAP = 1,
+  SINGLE_HOLD = 2,
+  DOUBLE_TAP = 3,
+  DOUBLE_HOLD = 4,
+  DOUBLE_SINGLE_TAP = 5, //send two single taps
+  TRIPLE_TAP = 6,
+  TRIPLE_HOLD = 7
+};
+
+enum gordon_layers
+{
+  _QWERTY = 0,
+  _SYMBOLS,
+  _MOUSE,
+  _NUMPAD,
+  _NAV,
+  _MACROS,
+  _FUNCTION,
+  _TEXTNAV
+};
+
+
+
+void register_hyper (void);
+void unregister_hyper (void);
+
+void register_ctrl_a (void); 
+void unregister_ctrl_a (void); 
+
+void register_alt_f7 (void); 
+void unregister_alt_f7 (void);
+
+void register_shift_f6 (void); 
+void unregister_shift_f6 (void); 
+
+void register_ctrl_shift (void); 
+void unregister_ctrl_shift (void); 
+
+void register_alt_shift (void); 
+void unregister_alt_shift (void);
+
+int cur_dance (qk_tap_dance_state_t *state); 
+int hold_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);
+
+void h_finished (qk_tap_dance_state_t *state, void *user_data);
+void h_reset (qk_tap_dance_state_t *state, void *user_data);
+
+void tab_finished (qk_tap_dance_state_t *state, void *user_data);
+void tab_reset (qk_tap_dance_state_t *state, void *user_data);
+
+void comma_finished (qk_tap_dance_state_t *state, void *user_data);
+void comma_reset (qk_tap_dance_state_t *state, void *user_data);
+
+void bt_finished (qk_tap_dance_state_t *state, void *user_data);
+void bt_reset (qk_tap_dance_state_t *state, void *user_data);
+
+// Macro Declarations
+enum {
+  INFOQM,
+  TIL_SLASH,
+  DEREF,
+  EQRIGHT,
+  TILD3,
+  TICK3,
+  ALTTAB_START,
+  ALTTAB_END
+};
+
+enum secret_strings {
+  KC_SECRET_1 = SAFE_RANGE,
+  KC_SECRET_2,
+  KC_SECRET_3,
+  KC_SECRET_4,
+  KC_SECRET_5,
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt);
+
+#endif

users/gordon/readme.md

@@ -0,0 +1,14 @@
+Copyright <year> <name> <email> @<github_username>
+
+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/>.

users/gordon/rules.mk

@@ -0,0 +1 @@
+SRC += gordon.c