[jackhill/qmk/firmware.git] / docs / feature_audio.md

# Audio

Your keyboard can make sounds! If you've got a Planck, Preonic, or basically any AVR keyboard that allows access to certain PWM-capable pins, you can hook up a simple speaker and make it beep. You can use those beeps to indicate layer transitions, modifiers, special keys, or just to play some funky 8bit tunes.

Up to two simultaneous audio voices are supported, one driven by timer 1 and another driven by timer 3.  The following pins can be defined as audio outputs in config.h:

Timer 1:
`#define B5_AUDIO`
`#define B6_AUDIO`
`#define B7_AUDIO`

Timer 3:
`#define C4_AUDIO`
`#define C5_AUDIO`
`#define C6_AUDIO`

If you add `AUDIO_ENABLE = yes` to your `rules.mk`, there's a couple different sounds that will automatically be enabled without any other configuration:

```
STARTUP_SONG // plays when the keyboard starts up (audio.c)
GOODBYE_SONG // plays when you press the RESET key (quantum.c)
AG_NORM_SONG // plays when you press AG_NORM (quantum.c)
AG_SWAP_SONG // plays when you press AG_SWAP (quantum.c)
MUSIC_ON_SONG // plays when music mode is activated (process_music.c)
MUSIC_OFF_SONG // plays when music mode is deactivated (process_music.c)
CHROMATIC_SONG // plays when the chromatic music mode is selected (process_music.c)
GUITAR_SONG // plays when the guitar music mode is selected (process_music.c)
VIOLIN_SONG // plays when the violin music mode is selected (process_music.c)
MAJOR_SONG // plays when the major music mode is selected (process_music.c)
```

You can override the default songs by doing something like this in your `config.h`:

```c
#ifdef AUDIO_ENABLE
  #define STARTUP_SONG SONG(STARTUP_SOUND)
#endif
```

A full list of sounds can be found in [quantum/audio/song_list.h](https://github.com/qmk/qmk_firmware/blob/master/quantum/audio/song_list.h) - feel free to add your own to this list! All available notes can be seen in [quantum/audio/musical_notes.h](https://github.com/qmk/qmk_firmware/blob/master/quantum/audio/musical_notes.h).

To play a custom sound at a particular time, you can define a song like this (near the top of the file):

```c
float my_song[][2] = SONG(QWERTY_SOUND);
```

And then play your song like this:

```c
PLAY_SONG(my_song);
```

Alternatively, you can play it in a loop like this:

```c
PLAY_LOOP(my_song);
```

It's advised that you wrap all audio features in `#ifdef AUDIO_ENABLE` / `#endif` to avoid causing problems when audio isn't built into the keyboard.

The available keycodes for audio are: 

* `AU_ON` - Turn Audio Feature on
* `AU_OFF` - Turn Audio Feature off
* `AU_TOG` - Toggle Audio Feature state

!> These keycodes turn all of the audio functionality on and off.  Turning it off means that audio feedback, audio clicky, music mode, etc. are disabled, completely. 

## ARM Audio Volume

For ARM devices, you can adjust the DAC sample values. If your board is too loud for you or your coworkers, you can set the max using `DAC_SAMPLE_MAX` in your `config.h`:

```c
#define DAC_SAMPLE_MAX 65535U
```

## Music Mode

The music mode maps your columns to a chromatic scale, and your rows to octaves. This works best with ortholinear keyboards, but can be made to work with others. All keycodes less than `0xFF` get blocked, so you won't type while playing notes - if you have special keys/mods, those will still work. A work-around for this is to jump to a different layer with KC_NOs before (or after) enabling music mode.

Recording is experimental due to some memory issues - if you experience some weird behavior, unplugging/replugging your keyboard will fix things.

Keycodes available:

* `MU_ON` - Turn music mode on
* `MU_OFF` - Turn music mode off
* `MU_TOG` - Toggle music mode
* `MU_MOD` - Cycle through the music modes:
  * `CHROMATIC_MODE` - Chromatic scale, row changes the octave
  * `GUITAR_MODE` - Chromatic scale, but the row changes the string (+5 st)
  * `VIOLIN_MODE` - Chromatic scale, but the row changes the string (+7 st)
  * `MAJOR_MODE` - Major scale

In music mode, the following keycodes work differently, and don't pass through:

* `LCTL` - start a recording
* `LALT` - stop recording/stop playing
* `LGUI` - play recording
* `KC_UP` - speed-up playback
* `KC_DOWN` - slow-down playback

The pitch standard (`PITCH_STANDARD_A`) is 440.0f by default - to change this, add something like this to your `config.h`:

    #define PITCH_STANDARD_A 432.0f

You can completely disable Music Mode as well. This is useful, if you're pressed for space on your controller.  To disable it, add this to your `config.h`:

    #define NO_MUSIC_MODE

### Music Mask

By default, `MUSIC_MASK` is set to `keycode < 0xFF` which means keycodes less than `0xFF` are turned into notes, and don't output anything. You can change this by defining this in your `config.h` like this:

    #define MUSIC_MASK keycode != KC_NO

Which will capture all keycodes - be careful, this will get you stuck in music mode until you restart your keyboard!

For a more advanced way to control which keycodes should still be processed, you can use `music_mask_kb(keycode)` in `<keyboard>.c` and `music_mask_user(keycode)` in your `keymap.c`:

    bool music_mask_user(uint16_t keycode) {
      switch (keycode) {
        case RAISE:
        case LOWER:
          return false;
        default:
          return true;
      }
    }

Things that return false are not part of the mask, and are always processed.

### Music Map

By default, the Music Mode uses the columns and row to determine the scale for the keys. For a board that uses a rectangular matrix that matches the keyboard layout, this is just fine.  However, for boards that use a more complicated matrix (such as the Planck Rev6, or many split keyboards) this would result in a very skewed experience.  

However, the Music Map option allows you to remap the scaling for the music mode, so it fits the layout, and is more natural. 

To enable this feature, add `#define MUSIC_MAP` to your `config.h` file, and then you will want to add a `uint8_t music_map` to your keyboard's `c` file, or your `keymap.c`.

```c
const uint8_t music_map[MATRIX_ROWS][MATRIX_COLS] = LAYOUT_ortho_4x12(
	36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
	24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
	12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
	 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11
);
```

You will want to use whichever `LAYOUT` macro that your keyboard uses here.  This maps it to the correct key location.  Start in  the bottom left of the keyboard layout, and  move to the right, and then upwards.  Fill in all the entries until you have a complete matrix.  

You can look at the [Planck Keyboard](https://github.com/qmk/qmk_firmware/blob/e9ace1487887c1f8b4a7e8e6d87c322988bec9ce/keyboards/planck/planck.c#L24-L29) as an example of how to implement this. 

## Audio Click

This adds a click sound each time you hit a button, to simulate click sounds from the keyboard. And the sounds are slightly different for each keypress, so it doesn't sound like a single long note, if you type rapidly. 

* `CK_TOGG` - Toggles the status (will play sound if enabled)
* `CK_ON` - Turns on Audio Click (plays sound)
* `CK_OFF` - Turns off Audio Click (doesn't play sound)
* `CK_RST` - Resets the frequency to the default state (plays sound at default frequency)
* `CK_UP` - Increases the frequency of the clicks (plays sound at new frequency)
* `CK_DOWN` - Decreases the frequency of the clicks (plays sound at new frequency)


The feature is disabled by default, to save space.  To enable it, add this to your `config.h`:

    #define AUDIO_CLICKY


You can configure the default, min and max frequencies, the stepping and built in randomness by defining these values: 

| Option | Default Value | Description |
|--------|---------------|-------------|
| `AUDIO_CLICKY_FREQ_DEFAULT` | 440.0f | Sets the default/starting audio frequency for the clicky sounds. |
| `AUDIO_CLICKY_FREQ_MIN` | 65.0f | Sets the lowest frequency (under 60f are a bit buggy). |
| `AUDIO_CLICKY_FREQ_MAX` | 1500.0f | Sets the the highest frequency. Too high may result in coworkers attacking you. |
| `AUDIO_CLICKY_FREQ_FACTOR` | 1.18921f| Sets the stepping of UP/DOWN key codes.  This is a multiplicative factor.  The default steps the frequency up/down by a musical minor third.  |
| `AUDIO_CLICKY_FREQ_RANDOMNESS`     |  0.05f |  Sets a factor of randomness for the clicks, Setting this to `0f` will make each click identical, and `1.0f` will make this sound much like the 90's computer screen scrolling/typing effect. | 
| `AUDIO_CLICKY_DELAY_DURATION` | 1 | An integer note duration where 1 is 1/16th of the tempo, or a sixty-fourth note (see `quantum/audio/musical_notes.h` for implementation details). The main clicky effect will be delayed by this duration.  Adjusting this to values around 6-12 will help compensate for loud switches. |


## MIDI Functionality

This is still a WIP, but check out `quantum/process_keycode/process_midi.c` to see what's happening. Enable from the Makefile.


## Audio Keycodes

|Key             |Aliases  |Description                       |
|----------------|---------|----------------------------------|
|`AU_ON`         |         |Audio mode on                     |
|`AU_OFF`        |         |Audio mode off                    |
|`AU_TOG`        |         |Toggles Audio mode                |
|`CLICKY_TOGGLE` |`CK_TOGG`|Toggles Audio clicky mode         |
|`CLICKY_UP`     |`CK_UP`  |Increases frequency of the clicks |
|`CLICKY_DOWN`   |`CK_DOWN`|Decreases frequency of the clicks |
|`CLICKY_RESET`  |`CK_RST` |Resets frequency to default       |
|`MU_ON`         |         |Turns on Music Mode               |
|`MU_OFF`        |         |Turns off Music Mode              |
|`MU_TOG`        |         |Toggles Music Mode                |
|`MU_MOD`        |         |Cycles through the music modes    |

<!-- FIXME: this formatting needs work

## Audio

```c
#ifdef AUDIO_ENABLE
    AU_ON,
    AU_OFF,
    AU_TOG,

    #ifdef FAUXCLICKY_ENABLE
        FC_ON,
        FC_OFF,
        FC_TOG,
    #endif

    // Music mode on/off/toggle
    MU_ON,
    MU_OFF,
    MU_TOG,

    // Music voice iterate
    MUV_IN,
    MUV_DE,
#endif
```

### Midi

#if !MIDI_ENABLE_STRICT || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
    MI_ON,  // send midi notes when music mode is enabled
    MI_OFF, // don't send midi notes when music mode is enabled
#endif

MIDI_TONE_MIN,
MIDI_TONE_MAX

MI_C = MIDI_TONE_MIN,
MI_Cs,
MI_Db = MI_Cs,
MI_D,
MI_Ds,
MI_Eb = MI_Ds,
MI_E,
MI_F,
MI_Fs,
MI_Gb = MI_Fs,
MI_G,
MI_Gs,
MI_Ab = MI_Gs,
MI_A,
MI_As,
MI_Bb = MI_As,
MI_B,

MIDI_TONE_KEYCODE_OCTAVES > 1

where x = 1-5:
MI_C_x,
MI_Cs_x,
MI_Db_x = MI_Cs_x,
MI_D_x,
MI_Ds_x,
MI_Eb_x = MI_Ds_x,
MI_E_x,
MI_F_x,
MI_Fs_x,
MI_Gb_x = MI_Fs_x,
MI_G_x,
MI_Gs_x,
MI_Ab_x = MI_Gs_x,
MI_A_x,
MI_As_x,
MI_Bb_x = MI_As_x,
MI_B_x,

MI_OCT_Nx 1-2
MI_OCT_x 0-7
MIDI_OCTAVE_MIN = MI_OCT_N2,
MIDI_OCTAVE_MAX = MI_OCT_7,
MI_OCTD, // octave down
MI_OCTU, // octave up

MI_TRNS_Nx 1-6
MI_TRNS_x 0-6
MIDI_TRANSPOSE_MIN = MI_TRNS_N6,
MIDI_TRANSPOSE_MAX = MI_TRNS_6,
MI_TRNSD, // transpose down
MI_TRNSU, // transpose up

MI_VEL_x 1-10
MIDI_VELOCITY_MIN = MI_VEL_1,
MIDI_VELOCITY_MAX = MI_VEL_9,
MI_VELD, // velocity down
MI_VELU, // velocity up

MI_CHx 1-16
MIDI_CHANNEL_MIN = MI_CH1
MIDI_CHANNEL_MAX = MI_CH16,
MI_CHD, // previous channel
MI_CHU, // next channel

MI_ALLOFF, // all notes off

MI_SUS, // sustain
MI_PORT, // portamento
MI_SOST, // sostenuto
MI_SOFT, // soft pedal
MI_LEG,  // legato

MI_MOD, // modulation
MI_MODSD, // decrease modulation speed
MI_MODSU, // increase modulation speed
#endif // MIDI_ADVANCED

-->
Commit	Line	Data
9b879b12	1	# Audio
9b879b12	2
22215a0e MW	3	Your keyboard can make sounds! If you've got a Planck, Preonic, or basically any AVR keyboard that allows access to certain PWM-capable pins, you can hook up a simple speaker and make it beep. You can use those beeps to indicate layer transitions, modifiers, special keys, or just to play some funky 8bit tunes.
	4
	5	Up to two simultaneous audio voices are supported, one driven by timer 1 and another driven by timer 3. The following pins can be defined as audio outputs in config.h:
8ffeaec3	6
22215a0e MW	7	Timer 1:
	8	`#define B5_AUDIO`
	9	`#define B6_AUDIO`
	10	`#define B7_AUDIO`
	11
	12	Timer 3:
	13	`#define C4_AUDIO`
	14	`#define C5_AUDIO`
	15	`#define C6_AUDIO`
9d1a08e3	16
	17	If you add `AUDIO_ENABLE = yes` to your `rules.mk`, there's a couple different sounds that will automatically be enabled without any other configuration:
	18
	19	```
	20	STARTUP_SONG // plays when the keyboard starts up (audio.c)
	21	GOODBYE_SONG // plays when you press the RESET key (quantum.c)
	22	AG_NORM_SONG // plays when you press AG_NORM (quantum.c)
	23	AG_SWAP_SONG // plays when you press AG_SWAP (quantum.c)
	24	MUSIC_ON_SONG // plays when music mode is activated (process_music.c)
	25	MUSIC_OFF_SONG // plays when music mode is deactivated (process_music.c)
	26	CHROMATIC_SONG // plays when the chromatic music mode is selected (process_music.c)
	27	GUITAR_SONG // plays when the guitar music mode is selected (process_music.c)
	28	VIOLIN_SONG // plays when the violin music mode is selected (process_music.c)
	29	MAJOR_SONG // plays when the major music mode is selected (process_music.c)
	30	```
	31
	32	You can override the default songs by doing something like this in your `config.h`:
	33
	34	```c
	35	#ifdef AUDIO_ENABLE
	36	#define STARTUP_SONG SONG(STARTUP_SOUND)
	37	#endif
	38	```
	39
	40	A full list of sounds can be found in [quantum/audio/song_list.h](https://github.com/qmk/qmk_firmware/blob/master/quantum/audio/song_list.h) - feel free to add your own to this list! All available notes can be seen in [quantum/audio/musical_notes.h](https://github.com/qmk/qmk_firmware/blob/master/quantum/audio/musical_notes.h).
	41
	42	To play a custom sound at a particular time, you can define a song like this (near the top of the file):
	43
	44	```c
	45	float my_song[][2] = SONG(QWERTY_SOUND);
	46	```
	47
	48	And then play your song like this:
	49
	50	```c
	51	PLAY_SONG(my_song);
	52	```
	53
	54	Alternatively, you can play it in a loop like this:
	55
	56	```c
	57	PLAY_LOOP(my_song);
	58	```
	59
	60	It's advised that you wrap all audio features in `#ifdef AUDIO_ENABLE` / `#endif` to avoid causing problems when audio isn't built into the keyboard.
	61
8ffeaec3 DJ	62	The available keycodes for audio are:
8ffeaec3 DJ	63
9739d6ba DJ	64	* `AU_ON` - Turn Audio Feature on
	65	* `AU_OFF` - Turn Audio Feature off
	66	* `AU_TOG` - Toggle Audio Feature state
	67
	68	!> These keycodes turn all of the audio functionality on and off. Turning it off means that audio feedback, audio clicky, music mode, etc. are disabled, completely.
8ffeaec3	69
3a0f3a5b DJ	70	## ARM Audio Volume
	71
	72	For ARM devices, you can adjust the DAC sample values. If your board is too loud for you or your coworkers, you can set the max using `DAC_SAMPLE_MAX` in your `config.h`:
	73
	74	```c
	75	#define DAC_SAMPLE_MAX 65535U
	76	```
8ffeaec3	77
7b0356d1	78	## Music Mode
9d1a08e3	79
bb53635f	80	The music mode maps your columns to a chromatic scale, and your rows to octaves. This works best with ortholinear keyboards, but can be made to work with others. All keycodes less than `0xFF` get blocked, so you won't type while playing notes - if you have special keys/mods, those will still work. A work-around for this is to jump to a different layer with KC_NOs before (or after) enabling music mode.
9d1a08e3	81
	82	Recording is experimental due to some memory issues - if you experience some weird behavior, unplugging/replugging your keyboard will fix things.
	83
	84	Keycodes available:
	85
	86	* `MU_ON` - Turn music mode on
	87	* `MU_OFF` - Turn music mode off
	88	* `MU_TOG` - Toggle music mode
	89	* `MU_MOD` - Cycle through the music modes:
	90	* `CHROMATIC_MODE` - Chromatic scale, row changes the octave
	91	* `GUITAR_MODE` - Chromatic scale, but the row changes the string (+5 st)
	92	* `VIOLIN_MODE` - Chromatic scale, but the row changes the string (+7 st)
	93	* `MAJOR_MODE` - Major scale
	94
	95	In music mode, the following keycodes work differently, and don't pass through:
	96
	97	* `LCTL` - start a recording
	98	* `LALT` - stop recording/stop playing
	99	* `LGUI` - play recording
	100	* `KC_UP` - speed-up playback
	101	* `KC_DOWN` - slow-down playback
	102
4f0dc945 DJ	103	The pitch standard (`PITCH_STANDARD_A`) is 440.0f by default - to change this, add something like this to your `config.h`:
	104
	105	#define PITCH_STANDARD_A 432.0f
	106
	107	You can completely disable Music Mode as well. This is useful, if you're pressed for space on your controller. To disable it, add this to your `config.h`:
	108
	109	#define NO_MUSIC_MODE
	110
	111	### Music Mask
	112
9d1a08e3	113	By default, `MUSIC_MASK` is set to `keycode < 0xFF` which means keycodes less than `0xFF` are turned into notes, and don't output anything. You can change this by defining this in your `config.h` like this:
	114
	115	#define MUSIC_MASK keycode != KC_NO
	116
	117	Which will capture all keycodes - be careful, this will get you stuck in music mode until you restart your keyboard!
	118
63d5c947 JH	119	For a more advanced way to control which keycodes should still be processed, you can use `music_mask_kb(keycode)` in `<keyboard>.c` and `music_mask_user(keycode)` in your `keymap.c`:
	120
	121	bool music_mask_user(uint16_t keycode) {
	122	switch (keycode) {
	123	case RAISE:
	124	case LOWER:
	125	return false;
	126	default:
	127	return true;
	128	}
	129	}
	130
	131	Things that return false are not part of the mask, and are always processed.
	132
4f0dc945	133	### Music Map
9d1a08e3	134
4f0dc945	135	By default, the Music Mode uses the columns and row to determine the scale for the keys. For a board that uses a rectangular matrix that matches the keyboard layout, this is just fine. However, for boards that use a more complicated matrix (such as the Planck Rev6, or many split keyboards) this would result in a very skewed experience.
9d1a08e3	136
4f0dc945	137	However, the Music Map option allows you to remap the scaling for the music mode, so it fits the layout, and is more natural.
6835ae82	138
4f0dc945 DJ	139	To enable this feature, add `#define MUSIC_MAP` to your `config.h` file, and then you will want to add a `uint8_t music_map` to your keyboard's `c` file, or your `keymap.c`.
	140
	141	```c
	142	const uint8_t music_map[MATRIX_ROWS][MATRIX_COLS] = LAYOUT_ortho_4x12(
	143	36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
	144	24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
	145	12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
	146	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
	147	);
	148	```
	149
	150	You will want to use whichever `LAYOUT` macro that your keyboard uses here. This maps it to the correct key location. Start in the bottom left of the keyboard layout, and move to the right, and then upwards. Fill in all the entries until you have a complete matrix.
	151
	152	You can look at the [Planck Keyboard](https://github.com/qmk/qmk_firmware/blob/e9ace1487887c1f8b4a7e8e6d87c322988bec9ce/keyboards/planck/planck.c#L24-L29) as an example of how to implement this.
6835ae82	153
a0309db9	154	## Audio Click
8b0b17a3 DJ	155
	156	This adds a click sound each time you hit a button, to simulate click sounds from the keyboard. And the sounds are slightly different for each keypress, so it doesn't sound like a single long note, if you type rapidly.
	157
	158	* `CK_TOGG` - Toggles the status (will play sound if enabled)
a0309db9 DJ	159	* `CK_ON` - Turns on Audio Click (plays sound)
	160	* `CK_OFF` - Turns off Audio Click (doesn't play sound)
	161	* `CK_RST` - Resets the frequency to the default state (plays sound at default frequency)
	162	* `CK_UP` - Increases the frequency of the clicks (plays sound at new frequency)
	163	* `CK_DOWN` - Decreases the frequency of the clicks (plays sound at new frequency)
8b0b17a3	164
e72e4b69	165
8b0b17a3 DJ	166	The feature is disabled by default, to save space. To enable it, add this to your `config.h`:
	167
	168	#define AUDIO_CLICKY
	169
8b0b17a3 DJ	170
	171	You can configure the default, min and max frequencies, the stepping and built in randomness by defining these values:
	172
	173	\| Option \| Default Value \| Description \|
	174	\|--------\|---------------\|-------------\|
	175	\| `AUDIO_CLICKY_FREQ_DEFAULT` \| 440.0f \| Sets the default/starting audio frequency for the clicky sounds. \|
	176	\| `AUDIO_CLICKY_FREQ_MIN` \| 65.0f \| Sets the lowest frequency (under 60f are a bit buggy). \|
	177	\| `AUDIO_CLICKY_FREQ_MAX` \| 1500.0f \| Sets the the highest frequency. Too high may result in coworkers attacking you. \|
d85110b6	178	\| `AUDIO_CLICKY_FREQ_FACTOR` \| 1.18921f\| Sets the stepping of UP/DOWN key codes. This is a multiplicative factor. The default steps the frequency up/down by a musical minor third. \|
a0309db9	179	\| `AUDIO_CLICKY_FREQ_RANDOMNESS` \| 0.05f \| Sets a factor of randomness for the clicks, Setting this to `0f` will make each click identical, and `1.0f` will make this sound much like the 90's computer screen scrolling/typing effect. \|
d85110b6	180	\| `AUDIO_CLICKY_DELAY_DURATION` \| 1 \| An integer note duration where 1 is 1/16th of the tempo, or a sixty-fourth note (see `quantum/audio/musical_notes.h` for implementation details). The main clicky effect will be delayed by this duration. Adjusting this to values around 6-12 will help compensate for loud switches. \|
8b0b17a3 DJ	181
	182
	183
	184
7b0356d1	185	## MIDI Functionality
9d1a08e3	186
9739d6ba	187	This is still a WIP, but check out `quantum/process_keycode/process_midi.c` to see what's happening. Enable from the Makefile.
9d1a08e3	188
8ffeaec3 DJ	189
	190	## Audio Keycodes
	191
	192	\|Key \|Aliases \|Description \|
	193	\|----------------\|---------\|----------------------------------\|
	194	\|`AU_ON` \| \|Audio mode on \|
	195	\|`AU_OFF` \| \|Audio mode off \|
	196	\|`AU_TOG` \| \|Toggles Audio mode \|
	197	\|`CLICKY_TOGGLE` \|`CK_TOGG`\|Toggles Audio clicky mode \|
	198	\|`CLICKY_UP` \|`CK_UP` \|Increases frequency of the clicks \|
	199	\|`CLICKY_DOWN` \|`CK_DOWN`\|Decreases frequency of the clicks \|
	200	\|`CLICKY_RESET` \|`CK_RST` \|Resets frequency to default \|
	201	\|`MU_ON` \| \|Turns on Music Mode \|
	202	\|`MU_OFF` \| \|Turns off Music Mode \|
	203	\|`MU_TOG` \| \|Toggles Music Mode \|
	204	\|`MU_MOD` \| \|Cycles through the music modes \|
	205
9b879b12	206	<!-- FIXME: this formatting needs work
	207
	208	## Audio
	209
	210	```c
	211	#ifdef AUDIO_ENABLE
	212	AU_ON,
	213	AU_OFF,
	214	AU_TOG,
	215
	216	#ifdef FAUXCLICKY_ENABLE
	217	FC_ON,
	218	FC_OFF,
	219	FC_TOG,
	220	#endif
	221
	222	// Music mode on/off/toggle
	223	MU_ON,
	224	MU_OFF,
	225	MU_TOG,
	226
	227	// Music voice iterate
	228	MUV_IN,
	229	MUV_DE,
	230	#endif
	231	```
	232
	233	### Midi
	234
	235	#if !MIDI_ENABLE_STRICT \|\| (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
	236	MI_ON, // send midi notes when music mode is enabled
	237	MI_OFF, // don't send midi notes when music mode is enabled
	238	#endif
	239
	240	MIDI_TONE_MIN,
	241	MIDI_TONE_MAX
	242
	243	MI_C = MIDI_TONE_MIN,
	244	MI_Cs,
	245	MI_Db = MI_Cs,
	246	MI_D,
	247	MI_Ds,
	248	MI_Eb = MI_Ds,
	249	MI_E,
	250	MI_F,
	251	MI_Fs,
	252	MI_Gb = MI_Fs,
	253	MI_G,
	254	MI_Gs,
	255	MI_Ab = MI_Gs,
	256	MI_A,
	257	MI_As,
	258	MI_Bb = MI_As,
	259	MI_B,
	260
	261	MIDI_TONE_KEYCODE_OCTAVES > 1
	262
	263	where x = 1-5:
	264	MI_C_x,
	265	MI_Cs_x,
	266	MI_Db_x = MI_Cs_x,
	267	MI_D_x,
	268	MI_Ds_x,
	269	MI_Eb_x = MI_Ds_x,
270	MI_E_x,
271	MI_F_x,
272	MI_Fs_x,
273	MI_Gb_x = MI_Fs_x,
274	MI_G_x,
275	MI_Gs_x,
276	MI_Ab_x = MI_Gs_x,
277	MI_A_x,
278	MI_As_x,
279	MI_Bb_x = MI_As_x,
280	MI_B_x,
281
282	MI_OCT_Nx 1-2
283	MI_OCT_x 0-7
284	MIDI_OCTAVE_MIN = MI_OCT_N2,
285	MIDI_OCTAVE_MAX = MI_OCT_7,
286	MI_OCTD, // octave down
287	MI_OCTU, // octave up
288
289	MI_TRNS_Nx 1-6
290	MI_TRNS_x 0-6
291	MIDI_TRANSPOSE_MIN = MI_TRNS_N6,
292	MIDI_TRANSPOSE_MAX = MI_TRNS_6,
293	MI_TRNSD, // transpose down
294	MI_TRNSU, // transpose up
295
296	MI_VEL_x 1-10
297	MIDI_VELOCITY_MIN = MI_VEL_1,
298	MIDI_VELOCITY_MAX = MI_VEL_9,
299	MI_VELD, // velocity down
300	MI_VELU, // velocity up
301
302	MI_CHx 1-16
303	MIDI_CHANNEL_MIN = MI_CH1
304	MIDI_CHANNEL_MAX = MI_CH16,
305	MI_CHD, // previous channel
306	MI_CHU, // next channel
307
308	MI_ALLOFF, // all notes off
309
310	MI_SUS, // sustain
311	MI_PORT, // portamento
312	MI_SOST, // sostenuto
313	MI_SOFT, // soft pedal
314	MI_LEG, // legato
315
316	MI_MOD, // modulation
317	MI_MODSD, // decrease modulation speed
318	MI_MODSU, // increase modulation speed
319	#endif // MIDI_ADVANCED
320
321	-->