Add songs to Clueboard 66% Hotswap

* Planck ajp10304 layout clean up

* Planck ajp10304 layout add Mac layer extensions

* JJ40 ajp10304 layout add Mac layer extensions

keyboards/clueboard/66_hotswap/gen1/config.h

@@ -26,7 +26,7 @@
 
 /* Speaker configuration
  */
-//#define SPEAKER_PIN B7 // FIXME: find the correct name for this define
+#define B7_AUDIO
 
 /* Backlight configuration
  */

keyboards/clueboard/66_hotswap/keymaps/default/keymap.c

@@ -6,6 +6,30 @@
 #define _FL 1
 #define _CL 2
 
+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 PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   /* Keymap _BL: Base Layer (Default Layer)
    */
@@ -30,7 +54,67 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 [_CL] = LAYOUT(
   BL_STEP,RGB_M_P,RGB_M_B,RGB_M_R,RGB_M_SW,RGB_M_SN,RGB_M_K,RGB_M_X,RGB_M_G,_______,_______,_______,_______,   RGB_TOG,           RGB_VAI, \
   _______,_______,_______,_______,RESET,  _______,_______,_______,_______,_______,_______,_______,_______,_______,                RGB_VAD, \
-  _______,_______,MO(_CL),_______,_______,_______,_______,_______,_______,_______,_______,_______,    _______,                             \
+  _______,_______,MO(_CL),_______,S_BSKTC,S_ODEJY,S_RCKBY,S_DOEDR,S_SCALE,S_ONEUP,S_COIN, S_SONIC,    S_ZELDA,                             \
   _______,MO(_FL),_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,MO(_FL),_______,        RGB_SAI,         \
   _______,_______,_______,                RGB_MOD,RGB_MOD,                        _______,_______,MO(_FL),_______,RGB_HUD,RGB_SAD,RGB_HUI),
 };
+
+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/66_hotswap/rules.mk

@@ -6,6 +6,7 @@ ARCH = AVR8
 F_USB = $(F_CPU)
 OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
 OPT_DEFS += -DBOOTLOADER_SIZE=4096
+EXTRAFLAGS += -flto
 
 # Build Options
 #   comment out to disable the options.
@@ -14,9 +15,9 @@ BOOTMAGIC_ENABLE = no 	# Virtual DIP switch configuration(+1000)
 MOUSEKEY_ENABLE = no	# Mouse keys(+4700)
 EXTRAKEY_ENABLE = yes 	# Audio control and System control(+450)
 CONSOLE_ENABLE = yes	# Console for debug(+400)
-COMMAND_ENABLE = yes	# Commands for debug and configuration
+COMMAND_ENABLE = no	# Commands for debug and configuration
 NKRO_ENABLE = yes	# USB Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
-AUDIO_ENABLE = no
+AUDIO_ENABLE = yes
 RGBLIGHT_ENABLE = yes	# Enable keyboard underlight functionality
 MIDI_ENABLE = no 	# MIDI controls
 UNICODE_ENABLE = no 	# Unicode

keyboards/jj40/keymaps/ajp10304/keymap.c

@@ -5,22 +5,28 @@
 
 extern keymap_config_t keymap_config;
 
-// Each layer gets a name for readability, which is then used in the keymap matrix below.
+enum jj40_layers {
-// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+  _QWERTY,
-// Layer names don't all need to be of the same length, obviously, and you can also skip them
+  _MAC,
-// entirely and just use numbers.
+  _LOWER,
-#define _QWERTY 0
+  _MLWR,
-#define _LOWER 1
+  _RAISE,
-#define _RAISE 2
+  _MRSE,
-#define _FUNC 3
+  _FUNC,
-#define _ADJUST 16
+  _MFNC,
-#define _DYN 6
+  _ADJUST,
+  _DYN
+};
 
-enum planck_keycodes {
+enum jj40_keycodes {
   QWERTY = SAFE_RANGE,
+  MAC,
   FUNC,
+  MFNC,
   LOWER,
+  MLWR,
   RAISE,
+  MRSE,
   DYNAMIC_MACRO_RANGE
 };
 
@@ -117,10 +123,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * `-----------------------------------------------------------------------------------'
  */
 [_ADJUST] = KEYMAP(\
-  M(0),    RESET,   QWERTY,  _______, _______, _______, _______, _______,             _______,           _______,              _______,  KC_DEL  ,\
+  M(0),     RESET,   QWERTY,  _______, _______, _______, _______, _______,             _______,           _______,              _______,  KC_DEL  ,\
-  KC_CAPS, _______, _______, _______, _______, _______, _______, KC_AUDIO_MUTE,       KC_AUDIO_VOL_UP,   KC_MEDIA_PLAY_PAUSE,  _______,  _______ ,\
+  KC_CAPS,  _______, _______, _______, _______, _______, _______, KC_AUDIO_MUTE,       KC_AUDIO_VOL_UP,   KC_MEDIA_PLAY_PAUSE,  _______,  _______ ,\
-  _______, _______, _______, _______, _______, _______, _______, KC_MEDIA_PREV_TRACK, KC_AUDIO_VOL_DOWN, KC_MEDIA_NEXT_TRACK,  _______,  _______ ,\
+  TG(_MAC), _______, _______, _______, _______, _______, _______, KC_MEDIA_PREV_TRACK, KC_AUDIO_VOL_DOWN, KC_MEDIA_NEXT_TRACK,  _______,  _______ ,\
-  _______, _______, _______, _______, _______, _______, _______, _______,             MO(_DYN),          _______,              _______,  _______ \
+  _______,  _______, _______, _______, _______, _______, _______, _______,             MO(_DYN),          _______,              _______,  _______ \
 ),
 
 /* DYN: Macro Recording and Playback
@@ -139,11 +145,38 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     _______,  _______, _______, _______, _______, DYN_MACRO_PLAY1, DYN_MACRO_PLAY2,  _______, _______, _______, _______, _______,\
     _______,  _______, _______, _______, _______, DYN_REC_STOP,    DYN_REC_STOP,     _______, _______, _______, _______, _______,\
     _______,  _______, _______, _______, _______, _______,         _______,          _______, _______, _______, _______, _______\
+),
+
+[_MAC]= KEYMAP(\
+    _______,  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,\
+    _______,  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,\
+    _______,  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,\
+    _______,  _______, _______, _______, MLWR,    _______, _______, MRSE,    _______, _______, _______, _______\
+),
+
+[_MLWR] = KEYMAP(\
+    _______,  _______,  _______,         _______, _______, _______, _______, _______, _______, _______, _______, _______,\
+    _______,  _______,  _______,         _______, _______, _______, _______, _______, _______, _______, _______, _______,\
+    _______,  KC_GRAVE, KC_NONUS_BSLASH, _______, _______, _______, _______, _______, _______, _______, _______, _______,\
+    _______,  _______,  _______,         _______, _______, _______, _______, _______, _______, _______, _______, _______\
+),
+
+[_MRSE] = KEYMAP(\
+    _______,  _______,  M(2),    _______, _______, _______, _______,       _______, _______, _______, _______,        _______       ,\
+    _______,  _______,  _______, _______, _______, _______, _______,       _______, _______, _______, _______,        LGUI(KC_EQL)  ,\
+    _______,  _______,  _______, _______, _______, _______, LALT(KC_LEFT), _______, _______, _______, LALT(KC_RIGHT), LGUI(KC_MINS) ,\
+    _______,  _______,  _______, _______, _______, _______, _______,       _______, _______, _______, _______,        _______       \
+),
+
+[_MFNC]= KEYMAP(\
+    _______,  _______,  _______,         _______, _______, _______, _______, _______, _______, _______, _______, _______             ,\
+    _______,  _______,  _______,         _______, _______, _______, _______, _______, _______, _______, _______, LGUI(KC_PENT)       ,\
+    _______,  KC_GRAVE, KC_NONUS_BSLASH, _______, _______, _______, _______, _______, _______, _______, _______, _______             ,\
+    _______,  _______,  _______,         _______, _______, _______, _______, _______, _______, _______, _______, _______             \
 )
 
 };
 
-
 void persistant_default_layer_set(uint16_t default_layer) {
   eeconfig_update_default_layer(default_layer);
   default_layer_set(default_layer);
@@ -179,10 +212,42 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
         update_tri_layer(_LOWER, _RAISE, _ADJUST);
       }
       return false;
-  }
+    case MLWR:
+      if (record->event.pressed) {
+        layer_on(_LOWER);
+        layer_on(_MLWR);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      } else {
+        layer_off(_LOWER);
+        layer_off(_MLWR);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      }
+      return false;
+    case MRSE:
+      if (record->event.pressed) {
+        layer_on(_RAISE);
+        layer_on(_MRSE);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      } else {
+        layer_off(_RAISE);
+        layer_off(_MRSE);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      }
+      return false;
+    case MFNC:
+      if (record->event.pressed) {
+        layer_on(_FUNC);
+        layer_on(_MFNC);
+      } else {
+        layer_off(_FUNC);
+        layer_off(_MFNC);
+      }
+      return false;
+    }
   return true;
 }
 
+
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
   switch(id) {
     // These would trigger when you hit a key mapped as M(0)
@@ -201,6 +266,13 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
             END
         );
       }
+    case 2: // Word Select - MAC
+      if (record->event.pressed) {
+        return MACRO(
+            DOWN(KC_LALT), DOWN(KC_RIGHT), UP(KC_RIGHT), DOWN(KC_LSFT), DOWN(KC_LEFT), UP(KC_LEFT), UP(KC_LSFT), UP(KC_LALT),
+            END
+        );
+      }
   }
   return MACRO_NONE;
 };

keyboards/jj40/keymaps/ajp10304/readme.md

@@ -1,12 +1,12 @@
 # AJP10304 Custom JJ40 Layout
 ###Based on my Planck layout of the same name.
 
-**Note:** In the tables below where there are two characters on a key, 
+**Note:** In the tables below where there are two characters on a key,
 the second is the output when shift is applied.
-  
+
 **Note:** The below tables assume a UK layout.
 
-##### Main Qwerty Layer 
+##### Main Qwerty Layer
 
 * Tab: when held, operates as shift.
 * Enter: when held, operates as shift.
@@ -33,7 +33,7 @@ Activated when `fn` held in the above `qwerty` layer.
 Activated when `Lower` is held in the above `qwerty` layer.
 
 * Numbers are along the top row, their shifted counterparts are on row 2.
-* WrdBks: `backspace` with `ctrl` applied. I.e. delete a word.  
+* WrdBks: `backspace` with `ctrl` applied. I.e. delete a word.
 * WrdDel: `delete` with `ctrl` applied. I.e. forward delete a word.
 
 |       |      |      |      |      |      |      |      |      |      |      |      |
@@ -42,45 +42,47 @@ Activated when `Lower` is held in the above `qwerty` layer.
 |  !    |   "  |   £  |   $  |   %  |   ^  |   &  |   *  |   (  |   )  |WrdDel|WrdBks|
 | Shift |  \|  |  `¬  |  #~  |  '@  |  -_  |  =+  |  #~  |  [{  |  ]}  |  '@  |Shift |
 |       |      |      |      |Lower | Del  |Space |      | Next | Vol- | Vol+ | Play |
- 
+
  ##### Raise Layer
  Activated when `Raise` is held in the above `qwerty` layer.
- 
+
  * Preferred layer for typing brackets.
  * Allows for cursor navigation to be used solely with the right hand.
  * WRDSEL: Select the word where the cursor is.
  * |< and >|: Apply `ctrl` to `left` and `right` respectively for word jumping.
 
-|       |      |      |      |      |      |       |      |      |      |       |      |      
+|       |      |      |      |      |      |       |      |      |      |       |      |
-| :---: |:----:| :---:| :---:| :---:| :---:| :---: | :---:| :---:| :---:| :---: | :---:| 
+| :---: |:----:| :---:| :---:| :---:| :---:| :---: | :---:| :---:| :---:| :---: | :---:|
 |   `   |      |WRDSEL|  [   |   ]  |      |       | PGUP | HOME |PGDOWN|       |PRNTSC|
 |   `   |      |      |  (   |   )  |      |       | HOME |  UP  | END  |       |ZOOM +|
 |       |      |      |  {   |   }  |      |&#124;<| LEFT | DOWN |RIGHT |>&#124;|ZOOM -|
-|       |      |      |      |      |  Alt | Enter |Raise |      |      |       |      |     
+|       |      |      |      |      |  Alt | Enter |Raise |      |      |       |      |
- 
+
 ##### Lower + Raise
 Activated when `Lower` and `Raise` are held together the above `qwerty` layer.
 
-* Audio controls in the same position as cursor keys from the `Raise` layer.  
+* Audio controls in the same position as cursor keys from the `Raise` layer.
 * ????: Runs a macro for outputting a text string.  Do not use this store passwords.
 * Reset: Enter bootloader for flashing firmware to the keyboard.
 * CAPS: Toggle caps lock.
 * DYN: Enter `DYN` layer.
+* MAC: Toggle MAC OS extensions to layers. This allows MLWR to be enabled with LOWER,
+MRSE with RAISE and MFNC with FUNC respectively.
 
-|       |      |      |      |      |      |      |      |      |      |      |      |      
+|       |      |      |      |      |      |      |      |      |      |      |      |
-| :---: |:----:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| 
+| :---: |:----:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:|
 | ????  | Reset|Qwerty|      |      |      |      |      |      |      |      |  Del |
 | CAPS  |      |      |      |      |      |      | Mute | Vol+ | Play |      |      |
-|       |      |      |      |      |      |      | Prev | Vol- | Next |      |      |
+| MAC   |      |      |      |      |      |      | Prev | Vol- | Next |      |      |
 |       |      |      |      |      |      |      |      | DYN  |      |      |      |
- 
+
 ##### DYN
 Activated when `DYN` held along with `Lower` and `Raise`
-Allows recording of macros.  To start recording the macro, press either REC1 or REC2. 
+Allows recording of macros.  To start recording the macro, press either REC1 or REC2.
-To finish the recording, press STOP. To replay the macro, press either PLAY1 or PLAY2.  
+To finish the recording, press STOP. To replay the macro, press either PLAY1 or PLAY2.
 
-|       |      |      |      |      |      |      |      |      |      |      |      |      
+|       |      |      |      |      |      |      |      |      |      |      |      |
-| :---: | :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| 
+| :---: | :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:|
 |       |      |      |      |      | REC1 | REC2 |      |      |      |      |      |
 |       |      |      |      |      | PLAY1| PLAY2|      |      |      |      |      |
 |       |      |      |      |      | STOP | STOP |      |      |      |      |      |

keyboards/planck/keymaps/ajp10304/keymap.c

@@ -5,22 +5,28 @@
 
 extern keymap_config_t keymap_config;
 
-// Each layer gets a name for readability, which is then used in the keymap matrix below.
+enum planck_layers {
-// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+  _QWERTY,
-// Layer names don't all need to be of the same length, obviously, and you can also skip them
+  _MAC,
-// entirely and just use numbers.
+  _LOWER,
-#define _QWERTY 0
+  _MLWR,
-#define _LOWER 1
+  _RAISE,
-#define _RAISE 2
+  _MRSE,
-#define _FUNC 3
+  _FUNC,
-#define _ADJUST 16
+  _MFNC,
-#define _DYN 6
+  _ADJUST,
+  _DYN
+};
 
 enum planck_keycodes {
   QWERTY = SAFE_RANGE,
+  MAC,
   FUNC,
+  MFNC,
   LOWER,
+  MLWR,
   RAISE,
+  MRSE,
   DYNAMIC_MACRO_RANGE
 };
 
@@ -117,10 +123,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * `-----------------------------------------------------------------------------------'
  */
 [_ADJUST] = {
-  {M(0),    RESET,   QWERTY,  _______, _______, _______, _______, _______,             _______,           _______,              _______,  KC_DEL  },
+  {M(0),     RESET,   QWERTY,  _______, _______, _______, _______, _______,             _______,           _______,              _______,  KC_DEL  },
-  {KC_CAPS, _______, _______, _______, _______, _______, _______, KC_AUDIO_MUTE,       KC_AUDIO_VOL_UP,   KC_MEDIA_PLAY_PAUSE,  _______,  _______ },
+  {KC_CAPS,  _______, _______, _______, _______, _______, _______, KC_AUDIO_MUTE,       KC_AUDIO_VOL_UP,   KC_MEDIA_PLAY_PAUSE,  _______,  _______ },
-  {_______, _______, _______, _______, _______, _______, _______, KC_MEDIA_PREV_TRACK, KC_AUDIO_VOL_DOWN, KC_MEDIA_NEXT_TRACK,  _______,  _______ },
+  {TG(_MAC), _______, _______, _______, _______, _______, _______, KC_MEDIA_PREV_TRACK, KC_AUDIO_VOL_DOWN, KC_MEDIA_NEXT_TRACK,  _______,  _______ },
-  {_______, _______, _______, _______, _______, _______, _______, _______,             MO(_DYN),          _______,              _______,  _______ }
+  {_______,  _______, _______, _______, _______, _______, _______, _______,             MO(_DYN),          _______,              _______,  _______ }
 },
 
 /* DYN: Macro Recording and Playback
@@ -141,8 +147,36 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     {_______,  _______, _______, _______, _______, _______,         _______,          _______, _______, _______, _______, _______}
 },
 
-};
 
+[_MAC]= {
+    {_______,  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______},
+    {_______,  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______},
+    {_______,  _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______},
+    {_______,  _______, _______, _______, MLWR,    _______, _______, MRSE,    _______, _______, _______, _______}
+},
+
+[_MLWR] = {
+    {_______,  _______,  _______,         _______, _______, _______, _______, _______, _______, _______, _______, _______},
+    {_______,  _______,  _______,         _______, _______, _______, _______, _______, _______, _______, _______, _______},
+    {_______,  KC_GRAVE, KC_NONUS_BSLASH, _______, _______, _______, _______, _______, _______, _______, _______, _______},
+    {_______,  _______,  _______,         _______, _______, _______, _______, _______, _______, _______, _______, _______}
+},
+
+[_MRSE] = {
+    {_______,  _______,  M(2),    _______, _______, _______, _______,       _______, _______, _______, _______,        _______       },
+    {_______,  _______,  _______, _______, _______, _______, _______,       _______, _______, _______, _______,        LGUI(KC_EQL)  },
+    {_______,  _______,  _______, _______, _______, _______, LALT(KC_LEFT), _______, _______, _______, LALT(KC_RIGHT), LGUI(KC_MINS) },
+    {_______,  _______,  _______, _______, _______, _______, _______,       _______, _______, _______, _______,        _______       }
+},
+
+[_MFNC]= {
+    {_______,  _______,  _______,         _______, _______, _______, _______, _______, _______, _______, _______, _______             },
+    {_______,  _______,  _______,         _______, _______, _______, _______, _______, _______, _______, _______, LGUI(KC_PENT)       },
+    {_______,  KC_GRAVE, KC_NONUS_BSLASH, _______, _______, _______, _______, _______, _______, _______, _______, _______             },
+    {_______,  _______,  _______,         _______, _______, _______, _______, _______, _______, _______, _______, _______             }
+},
+
+};
 
 void persistant_default_layer_set(uint16_t default_layer) {
   eeconfig_update_default_layer(default_layer);
@@ -179,10 +213,42 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
         update_tri_layer(_LOWER, _RAISE, _ADJUST);
       }
       return false;
-  }
+    case MLWR:
+      if (record->event.pressed) {
+        layer_on(_LOWER);
+        layer_on(_MLWR);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      } else {
+        layer_off(_LOWER);
+        layer_off(_MLWR);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      }
+      return false;
+    case MRSE:
+      if (record->event.pressed) {
+        layer_on(_RAISE);
+        layer_on(_MRSE);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      } else {
+        layer_off(_RAISE);
+        layer_off(_MRSE);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      }
+      return false;
+    case MFNC:
+      if (record->event.pressed) {
+        layer_on(_FUNC);
+        layer_on(_MFNC);
+      } else {
+        layer_off(_FUNC);
+        layer_off(_MFNC);
+      }
+      return false;
+    }
   return true;
 }
 
+
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
   switch(id) {
     // These would trigger when you hit a key mapped as M(0)
@@ -201,6 +267,13 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
             END
         );
       }
+    case 2: // Word Select - MAC
+      if (record->event.pressed) {
+        return MACRO(
+            DOWN(KC_LALT), DOWN(KC_RIGHT), UP(KC_RIGHT), DOWN(KC_LSFT), DOWN(KC_LEFT), UP(KC_LEFT), UP(KC_LSFT), UP(KC_LALT),
+            END
+        );
+      }
   }
   return MACRO_NONE;
 };

keyboards/planck/keymaps/ajp10304/readme.md

@@ -65,12 +65,14 @@ Activated when `Lower` and `Raise` are held together the above `qwerty` layer.
 * Reset: Enter bootloader for flashing firmware to the keyboard.
 * CAPS: Toggle caps lock.
 * DYN: Enter `DYN` layer.
+* MAC: Toggle MAC OS extensions to layers. This allows MLWR to be enabled with LOWER, 
+MRSE with RAISE and MFNC with FUNC respectively.
 
 |       |      |      |      |      |      |      |      |      |      |      |      |      
 | :---: |:----:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| :---:| 
 | ????  | Reset|Qwerty|      |      |      |      |      |      |      |      |  Del |
 | CAPS  |      |      |      |      |      |      | Mute | Vol+ | Play |      |      |
-|       |      |      |      |      |      |      | Prev | Vol- | Next |      |      |
+| MAC   |      |      |      |      |      |      | Prev | Vol- | Next |      |      |
 |       |      |      |      |      |      |      |      | DYN  |      |      |      |
  
 ##### DYN

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/keymaps/aviator/config.h

@@ -3,8 +3,10 @@
 
 #include "config_common.h"
 
+#ifndef LIGHT_CONFIG_H
 #define BACKLIGHT_BREATHING
 #define BREATHING_PERIOD 3
+#endif
 
 #ifdef AUDIO_ENABLE
     #define STARTUP_SONG SONG(PLANCK_SOUND)

keyboards/planck/keymaps/aviator/keymap.c

@@ -126,14 +126,16 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
     case QWERTY:
       if (record->event.pressed) {
         set_single_persistent_default_layer(_QWERTY);
-        breathing_self_disable();
+        #ifdef BACKLIGHT_BREATHING
+          breathing_self_disable();
+        #endif
       }
       return false;
       break;
     case DATA:
       if (record->event.pressed) {
         set_single_persistent_default_layer(_DATA);
-        #ifdef BACKLIGHT_ENABLE
+        #ifdef BACKLIGHT_BREATHING
           breathing_enable();
         #endif
       }
@@ -144,7 +146,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
         layer_on(_LOWER);
         uint8_t default_layer = biton32(default_layer_state);
         if (default_layer == _QWERTY) {
-          #ifdef BACKLIGHT_ENABLE
+          #ifdef BACKLIGHT_BREATHING
             breathing_enable();
           #endif
         }
@@ -153,7 +155,9 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
         layer_off(_LOWER);
         uint8_t default_layer = biton32(default_layer_state);
         if (default_layer == _QWERTY) {
-          breathing_self_disable();
+          #ifdef BACKLIGHT_BREATHING
+            breathing_self_disable();
+          #endif
         }
         update_tri_layer(_LOWER, _RAISE, _ADJUST);
       }
@@ -164,7 +168,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
         layer_on(_RAISE);
         uint8_t default_layer = biton32(default_layer_state);
         if (default_layer == _QWERTY) {
-          #ifdef BACKLIGHT_ENABLE
+          #ifdef BACKLIGHT_BREATHING
             breathing_enable();
           #endif
         }
@@ -173,7 +177,9 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
         layer_off(_RAISE);
         uint8_t default_layer = biton32(default_layer_state);
         if (default_layer == _QWERTY) {
-          breathing_self_disable();
+          #ifdef BACKLIGHT_BREATHING
+            breathing_self_disable();
+          #endif
         }
         update_tri_layer(_LOWER, _RAISE, _ADJUST);
       }
@@ -182,7 +188,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
     case BACKLIT:
       if (record->event.pressed) {
         register_code(KC_RSFT);
-        #ifdef BACKLIGHT_ENABLE
+        #ifdef BACKLIGHT_BREATHING
           backlight_step();
         #endif
       } else {

keyboards/planck/keymaps/cbbrowne/config.h

@@ -27,7 +27,10 @@
 #include "../../config.h"
 
 #define LEADER_TIMEOUT 300
+
+#ifndef LIGHT_CONFIG_H
 #define BACKLIGHT_BREATHING
+#endif
 
 /* cbbrowne user configuration */
 

keyboards/planck/keymaps/cbbrowne/keymap.c

@@ -219,7 +219,7 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
     if (record->event.pressed)
       {
 	layer_on(_RAISE);
-#ifdef BACKLIGHT_ENABLE
+#ifdef BACKLIGHT_BREATHING
 	breathing_period_set(2);
 	breathing_pulse();
 #endif
@@ -235,7 +235,7 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
     if (record->event.pressed)
       {
 	layer_on(_LOWER);
-#ifdef BACKLIGHT_ENABLE
+#ifdef BACKLIGHT_BREATHING
 	breathing_period_set(2);
 	breathing_pulse();
 #endif

keyboards/planck/keymaps/khord/config.h

@@ -12,7 +12,9 @@
                                 }
 #endif
 
+#ifndef LIGHT_CONFIG_H
 #define BACKLIGHT_BREATHING
+#endif
 #define TAPPING_TERM 150
 
 #define MUSIC_MASK (keycode != KC_NO)

keyboards/planck/keymaps/khord/keymap.c

@@ -123,22 +123,30 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
   switch(id) {
     case MACRO_BREATH_TOGGLE:
       if (record->event.pressed) {
-        breathing_toggle();
+        #ifdef BACKLIGHT_BREATHING
+          breathing_toggle();
+        #endif
       }
       break;
     case MACRO_BREATH_SPEED_INC:
       if (record->event.pressed) {
-        breathing_period_inc();
+        #ifdef BACKLIGHT_BREATHING
+          breathing_period_inc();
+        #endif
       }
       break;
     case MACRO_BREATH_SPEED_DEC:
       if (record->event.pressed) {
-        breathing_period_dec();
+        #ifdef BACKLIGHT_BREATHING
+          breathing_period_dec();
+        #endif
       }
       break;
     case MACRO_BREATH_DEFAULT:
       if (record->event.pressed) {
-        breathing_period_default();
+        #ifdef BACKLIGHT_BREATHING
+          breathing_period_default();
+        #endif
       }
       break;
   }

keyboards/planck/keymaps/pvc/config.h

@@ -25,9 +25,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define MATRIX_COLS 12
 
 /* Planck PCB default pin-out */
+#ifndef LIGHT_CONFIG_H
 #define MATRIX_ROW_PINS { D0, D5, B5, B6 }
 #define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 }
 #define UNUSED_PINS
+#endif
 
 /*
  * MIDI options
@@ -69,7 +71,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* Only print user print statements */
 #define USER_PRINT
 
+#ifndef LIGHT_CONFIG_H
 #define BACKLIGHT_BREATHING
+#endif
 
 /* disable action features */
 //#define NO_ACTION_LAYER

keyboards/planck/keymaps/pvc/keymap.c

@@ -316,28 +316,36 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
         case MACRO_BREATH_TOGGLE:
             if (record->event.pressed)
             {
+              #ifdef BACKLIGHT_BREATHING
                 breathing_toggle();
+              #endif
             }
             break;
 
         case MACRO_BREATH_SPEED_INC:
             if (record->event.pressed)
             {
+              #ifdef BACKLIGHT_BREATHING
                 breathing_period_inc();
+              #endif
             }
             break;
 
         case MACRO_BREATH_SPEED_DEC:
             if (record->event.pressed)
             {
+              #ifdef BACKLIGHT_BREATHING
                 breathing_period_dec();
+              #endif
             }
             break;
 
         case MACRO_BREATH_DEFAULT:
             if (record->event.pressed)
             {
+              #ifdef BACKLIGHT_BREATHING
                 breathing_period_default();
+              #endif
             }
             break;
 
@@ -352,8 +360,10 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
             if (record->event.pressed)
             {
                 layer_on(LAYER_UPPER);
-                breathing_period_set(2);
+                #ifdef BACKLIGHT_BREATHING
-                breathing_pulse();
+                  breathing_period_set(2);
+                  breathing_pulse();
+                #endif
                 update_tri_layer(LAYER_LOWER, LAYER_UPPER, LAYER_ADJUST);
             }
             else
@@ -367,8 +377,10 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
             if (record->event.pressed)
             {
                 layer_on(LAYER_LOWER);
-                breathing_period_set(2);
+                #ifdef BACKLIGHT_BREATHING
-                breathing_pulse();
+                  breathing_period_set(2);
+                  breathing_pulse();
+                #endif
                 update_tri_layer(LAYER_LOWER, LAYER_UPPER, LAYER_ADJUST);
             }
             else
@@ -381,14 +393,18 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
         case MACRO_FUNCTION:
             if (record->event.pressed)
             {
-                breathing_period_set(3);
+                #ifdef BACKLIGHT_BREATHING
-                breathing_enable();
+                  breathing_period_set(3);
+                  breathing_enable();
+                #endif
                 layer_on(LAYER_FUNCTION);
             }
             else
             {
-                breathing_period_set(1);
+                #ifdef BACKLIGHT_BREATHING
-                breathing_self_disable();
+                  breathing_period_set(1);
+                  breathing_self_disable();
+                #endif
                 layer_off(LAYER_FUNCTION);
             }
             break;

keyboards/planck/keymaps/zrichard/config.h

@@ -26,9 +26,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define MATRIX_COLS 12
 
 /* Planck PCB default pin-out */
+#ifndef LIGHT_CONFIG_H
 #define MATRIX_ROW_PINS { D0, D5, B5, B6 }
 #define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 }
 #define UNUSED_PINS
+#endif
 
 /* Prevent use of disabled MIDI features in the keymap */
 //#define MIDI_ENABLE_STRICT 1
@@ -64,7 +66,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* Only print user print statements */
 #define USER_PRINT
 
+#ifndef LIGHT_CONFIG_H
 #define BACKLIGHT_BREATHING
+#endif
 
 /* disable action features */
 //#define NO_ACTION_LAYER

keyboards/planck/keymaps/zrichard/keymap.c

@@ -325,28 +325,36 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
         case MACRO_BREATH_TOGGLE:
             if (record->event.pressed)
             {
+              #ifdef BACKLIGHT_BREATHING
                 breathing_toggle();
+              #endif
             }
             break;
 
         case MACRO_BREATH_SPEED_INC:
             if (record->event.pressed)
             {
+              #ifdef BACKLIGHT_BREATHING
                 breathing_period_inc();
+              #endif
             }
             break;
 
         case MACRO_BREATH_SPEED_DEC:
             if (record->event.pressed)
             {
+              #ifdef BACKLIGHT_BREATHING
                 breathing_period_dec();
+              #endif
             }
             break;
 
         case MACRO_BREATH_DEFAULT:
             if (record->event.pressed)
             {
+              #ifdef BACKLIGHT_BREATHING
                 breathing_period_default();
+              #endif
             }
             break;
 
@@ -361,8 +369,10 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
             if (record->event.pressed)
             {
                 layer_on(LAYER_UPPER);
-                breathing_period_set(2);
+                #ifdef BACKLIGHT_BREATHING
-                breathing_pulse();
+                  breathing_period_set(2);
+                  breathing_pulse();
+                #endif
                 update_tri_layer(LAYER_LOWER, LAYER_UPPER, LAYER_ADJUST);
             }
             else
@@ -376,8 +386,10 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
             if (record->event.pressed)
             {
                 layer_on(LAYER_LOWER);
-                breathing_period_set(2);
+                #ifdef BACKLIGHT_BREATHING
-                breathing_pulse();
+                  breathing_period_set(2);
+                  breathing_pulse();
+                #endif
                 update_tri_layer(LAYER_LOWER, LAYER_UPPER, LAYER_ADJUST);
             }
             else
@@ -390,14 +402,18 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
         case MACRO_FUNCTION:
             if (record->event.pressed)
             {
-                breathing_period_set(3);
+                #ifdef BACKLIGHT_BREATHING
-                breathing_enable();
+                  breathing_period_set(3);
+                  breathing_enable();
+                #endif
                 layer_on(LAYER_FUNCTION);
             }
             else
             {
-                breathing_period_set(1);
+                #ifdef BACKLIGHT_BREATHING
-                breathing_self_disable();
+                  breathing_period_set(1);
+                  breathing_self_disable();
+                #endif
                 layer_off(LAYER_FUNCTION);
             }
             break;

keyboards/preonic/preonic.h

@@ -14,7 +14,7 @@
 	{ k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b }, \
 	{ k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1a, k1b }, \
 	{ k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k2a, k2b }, \
-	{ k30, k31, k32, k33, k34, k35, k35, k37, k38, k39, k3a, k3b }, \
+	{ k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3a, k3b }, \
 	{ k40, k41, k42, k43, k44, k45, k45, k47, k48, k49, k4a, k4b } \
 }
 
@@ -29,7 +29,7 @@
 	{ k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b }, \
 	{ k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1a, k1b }, \
 	{ k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k2a, k2b }, \
-	{ k30, k31, k32, k33, k34, k35, k35, k37, k38, k39, k3a, k3b }, \
+	{ k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3a, k3b }, \
 	{ k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k4a, k4b } \
 }
 

keyboards/preonic/rev2/info.json

@@ -1,3 +1,4 @@
 {
-  "identifier": "FEED:6061:0002"
+  "identifier": "FEED:6061:0002",
-}
+  "bootloader": "qmk-dfu"
+}

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;
@@ -200,7 +247,7 @@ void audio_init()
 
 void stop_all_notes()
 {
-    dprintf("audio stop all notes");
+    dprintf("audio stop all notes\n");
 
     if (!audio_initialized) {
         audio_init();
@@ -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
@@ -233,7 +280,7 @@ void stop_all_notes()
 
 void stop_note(float freq)
 {
-    dprintf("audio stop note freq=%d", (int)freq);
+    dprintf("audio stop note freq=%d\n", (int)freq);
 
     if (playing_note) {
         if (!audio_initialized) {
@@ -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);
             }
@@ -620,7 +679,7 @@ ISR(TIMER1_COMPA_vect)
 
 void play_note(float freq, int vol) {
 
-    dprintf("audio play note freq=%d vol=%d", (int)freq, vol);
+    dprintf("audio play note freq=%d vol=%d\n", (int)freq, vol);
 
     if (!audio_initialized) {
         audio_init();
@@ -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

@@ -47,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;
@@ -69,8 +69,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)
@@ -241,7 +241,7 @@ static const dacsample_t dac_buffer_2[DAC_BUFFER_SIZE] = {
  * DAC streaming callback.
  */
 size_t nx = 0, ny = 0, nz = 0;
-static void end_cb1(DACDriver *dacp, dacsample_t *buffer, size_t n) {
+static void end_cb1(DACDriver *dacp, const dacsample_t *buffer, size_t n) {
 
   (void)dacp;
 
@@ -434,7 +434,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)) {
@@ -457,16 +457,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 (GET_CHANNEL_1_FREQ != (uint16_t)freq_alt) {
+                        UPDATE_CHANNEL_1_FREQ(freq_alt);
+                    }
+                    //note_timbre;
+                } else {
+                    STOP_CHANNEL_1();
                     if (GET_CHANNEL_2_FREQ != (uint16_t)freq_alt) {
                         UPDATE_CHANNEL_2_FREQ(freq_alt);
                     }
@@ -492,7 +498,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)) {
@@ -515,17 +521,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 (GET_CHANNEL_2_FREQ != (uint16_t)freq) {
+                UPDATE_CHANNEL_2_FREQ(freq);
             if (GET_CHANNEL_1_FREQ != (uint16_t)freq) {
                 UPDATE_CHANNEL_1_FREQ(freq);
             }
@@ -545,10 +553,10 @@ 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 (GET_CHANNEL_1_FREQ != (uint16_t)freq) {
@@ -597,7 +605,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);
             }
@@ -628,7 +636,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;
@@ -762,8 +771,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/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;