+
### Lists
@@ -84,7 +84,7 @@ Nested mixed:
* `lib/python/qmk/cli/generate/config_h.py`
* `lib/python/qmk/cli/generate/rules_mk.py`
-### Emoji :id=emoji
+### Emoji {#emoji}
#### Direct:
diff --git a/docs/_aliases.json b/docs/_aliases.json
new file mode 100644
index 0000000000..0dfcdea1e2
--- /dev/null
+++ b/docs/_aliases.json
@@ -0,0 +1,77 @@
+{
+ "/adding_a_keyboard_to_qmk": "/hardware_keyboard_guidelines",
+ "/build_environment_setup": "/newbs_getting_started",
+ "/cli_dev_configuration": "/cli_configuration",
+ "/dynamic_macros": "/feature_dynamic_macros",
+ "/feature_common_shortcuts": "/feature_advanced_keycodes",
+ "/flashing_bootloadhid": "/flashing",
+ "/getting_started_build_tools": "/newbs_getting_started",
+ "/getting_started_getting_help": "/support",
+ "/glossary": "/reference_glossary",
+ "/key_lock": "/feature_key_lock",
+ "/make_instructions": "/getting_started_make_guide",
+ "/python_development": "/cli_development",
+ "/space_cadet_shift": "/feature_space_cadet_shift",
+ "/tap_dance": "/feature_tap_dance",
+ "/tutorial": "/newbs",
+ "/unicode": "/feature_unicode",
+
+ "/features/bluetooth": "/features/wireless",
+
+ "/adc_driver": "/drivers/adc",
+ "/apa102_driver": "/drivers/apa102",
+ "/audio_driver": "/drivers/audio",
+ "/eeprom_driver": "/drivers/eeprom",
+ "/feature_audio": "/features/audio",
+ "/feature_auto_shift": "/features/auto_shift",
+ "/feature_autocorrect": "/features/autocorrect",
+ "/feature_backlight": "/features/backlight",
+ "/feature_bluetooth": "/features/wireless",
+ "/feature_bootmagic": "/features/bootmagic",
+ "/feature_caps_word": "/features/caps_word",
+ "/feature_combo": "/features/combo",
+ "/feature_command": "/features/command",
+ "/feature_digitizer": "/features/digitizer",
+ "/feature_dip_switch": "/features/dip_switch",
+ "/feature_dynamic_macros": "/features/dynamic_macros",
+ "/feature_encoders": "/features/encoders",
+ "/feature_grave_esc": "/features/grave_esc",
+ "/feature_haptic_feedback": "/features/haptic_feedback",
+ "/feature_hd44780": "/features/hd44780",
+ "/feature_joystick": "/features/joystick",
+ "/feature_key_lock": "/features/key_lock",
+ "/feature_key_overrides": "/features/key_overrides",
+ "/feature_leader_key": "/features/leader_key",
+ "/feature_led_indicators": "/features/led_indicators",
+ "/feature_led_matrix": "/features/led_matrix",
+ "/feature_midi": "/features/midi",
+ "/feature_mouse_keys": "/features/mouse_keys",
+ "/feature_oled_driver": "/features/oled_driver",
+ "/feature_os_detection": "/features/os_detection",
+ "/feature_pointing_device": "/features/pointing_device",
+ "/feature_programmable_button": "/features/programmable_button",
+ "/feature_ps2_mouse": "/features/ps2_mouse",
+ "/feature_rawhid": "/features/rawhid",
+ "/feature_repeat_key": "/features/repeat_key",
+ "/feature_rgb_matrix": "/features/rgb_matrix",
+ "/feature_rgblight": "/features/rgblight",
+ "/feature_secure": "/features/secure",
+ "/feature_send_string": "/features/send_string",
+ "/feature_sequencer": "/features/sequencer",
+ "/feature_space_cadet": "/features/space_cadet",
+ "/feature_split_keyboard": "/features/split_keyboard",
+ "/feature_st7565": "/features/st7565",
+ "/feature_stenography": "/features/stenography",
+ "/feature_swap_hands": "/features/swap_hands",
+ "/feature_tap_dance": "/features/tap_dance",
+ "/feature_tri_layer": "/features/tri_layer",
+ "/feature_unicode": "/features/unicode",
+ "/feature_wpm": "/features/wpm",
+ "/flash_driver": "/drivers/flash",
+ "/gpio_control": "/drivers/gpio",
+ "/i2c_driver": "/drivers/i2c",
+ "/serial_driver": "/drivers/serial",
+ "/spi_driver": "/drivers/spi",
+ "/uart_driver": "/drivers/uart",
+ "/ws2812_driver": "/drivers/ws2812"
+}
diff --git a/docs/_sidebar.json b/docs/_sidebar.json
index f1b7c156e6..d237b0e1d0 100644
--- a/docs/_sidebar.json
+++ b/docs/_sidebar.json
@@ -24,6 +24,13 @@
{ "text": "Glossary", "link": "/reference_glossary" }
]
},
+ {
+ "text": "Licensing",
+ "items": [
+ { "text": "License Violations", "link": "/license_violations" },
+ { "text": "Proprietary Libraries", "link": "/proprietary_libs" }
+ ]
+ },
{
"text": "Configurator",
"items": [
@@ -59,18 +66,13 @@
"items": [
{ "text": "Customizing Functionality", "link": "/custom_quantum_functions" },
{ "text": "Driver Installation with Zadig", "link": "/driver_installation_zadig" },
+ { "text": "Community Modules", "link": "/features/community_modules" },
{ "text": "Keymap Overview", "link": "/keymap" },
{
"text": "Development Environments",
"items": [{ "text": "Docker Guide", "link": "/getting_started_docker" }]
},
- {
- "text": "Flashing",
- "items": [
- { "text": "Flashing", "link": "/flashing" },
- { "text": "Flashing ATmega32A (ps2avrgb)", "link": "/flashing_bootloadhid" }
- ]
- },
+ { "text": "Flashing", "link": "/flashing" },
{
"text": "IDEs",
"items": [
@@ -103,45 +105,46 @@
{
"text": "Advanced Keycodes",
"items": [
- { "text": "Command", "link": "/feature_command" },
- { "text": "Dynamic Macros", "link": "/feature_dynamic_macros" },
- { "text": "Grave Escape", "link": "/feature_grave_esc" },
- { "text": "Leader Key", "link": "/feature_leader_key" },
+ { "text": "Command", "link": "/features/command" },
+ { "text": "Dynamic Macros", "link": "/features/dynamic_macros" },
+ { "text": "Grave Escape", "link": "/features/grave_esc" },
+ { "text": "Leader Key", "link": "/features/leader_key" },
{ "text": "Mod-Tap", "link": "/mod_tap" },
{ "text": "Macros", "link": "/feature_macros" },
- { "text": "Mouse Keys", "link": "/feature_mouse_keys" },
- { "text": "Programmable Button", "link": "/feature_programmable_button" },
- { "text": "Repeat Key", "link": "/feature_repeat_key" },
- { "text": "Space Cadet Shift", "link": "/feature_space_cadet" },
+ { "text": "Mouse Keys", "link": "/features/mouse_keys" },
+ { "text": "Programmable Button", "link": "/features/programmable_button" },
+ { "text": "Repeat Key", "link": "/features/repeat_key" },
+ { "text": "Space Cadet Shift", "link": "/features/space_cadet" },
{ "text": "US ANSI Shifted Keys", "link": "/keycodes_us_ansi_shifted" }
]
},
{
"text": "Software Features",
"items": [
- { "text": "Auto Shift", "link": "/feature_auto_shift" },
- { "text": "Autocorrect", "link": "/feature_autocorrect" },
- { "text": "Caps Word", "link": "/feature_caps_word" },
- { "text": "Combos", "link": "/feature_combo" },
+ { "text": "Auto Shift", "link": "/features/auto_shift" },
+ { "text": "Autocorrect", "link": "/features/autocorrect" },
+ { "text": "Caps Word", "link": "/features/caps_word" },
+ { "text": "Combos", "link": "/features/combo" },
{ "text": "Debounce API", "link": "/feature_debounce_type" },
- { "text": "Digitizer", "link": "/feature_digitizer" },
+ { "text": "Digitizer", "link": "/features/digitizer" },
{ "text": "EEPROM", "link": "/feature_eeprom" },
- { "text": "Key Lock", "link": "/feature_key_lock" },
- { "text": "Key Overrides", "link": "/feature_key_overrides" },
+ { "text": "Key Lock", "link": "/features/key_lock" },
+ { "text": "Key Overrides", "link": "/features/key_overrides" },
{ "text": "Layers", "link": "/feature_layers" },
+ { "text": "Layer Lock", "link": "/features/layer_lock" },
{ "text": "One Shot Keys", "link": "/one_shot_keys" },
- { "text": "OS Detection", "link": "/feature_os_detection" },
- { "text": "Raw HID", "link": "/feature_rawhid" },
- { "text": "Secure", "link": "/feature_secure" },
- { "text": "Send String", "link": "/feature_send_string" },
- { "text": "Sequencer", "link": "/feature_sequencer" },
- { "text": "Swap Hands", "link": "/feature_swap_hands" },
- { "text": "Tap Dance", "link": "/feature_tap_dance" },
+ { "text": "OS Detection", "link": "/features/os_detection" },
+ { "text": "Raw HID", "link": "/features/rawhid" },
+ { "text": "Secure", "link": "/features/secure" },
+ { "text": "Send String", "link": "/features/send_string" },
+ { "text": "Sequencer", "link": "/features/sequencer" },
+ { "text": "Swap Hands", "link": "/features/swap_hands" },
+ { "text": "Tap Dance", "link": "/features/tap_dance" },
{ "text": "Tap-Hold Configuration", "link": "/tap_hold" },
- { "text": "Tri Layer", "link": "/feature_tri_layer" },
- { "text": "Unicode", "link": "/feature_unicode" },
+ { "text": "Tri Layer", "link": "/features/tri_layer" },
+ { "text": "Unicode", "link": "/features/unicode" },
{ "text": "Userspace", "link": "/feature_userspace" },
- { "text": "WPM Calculation", "link": "/feature_wpm" }
+ { "text": "WPM Calculation", "link": "/features/wpm" }
]
},
{
@@ -157,35 +160,36 @@
{ "text": "Quantum Painter LVGL Integration", "link": "/quantum_painter_lvgl" }
]
},
- { "text": "HD44780 LCD Driver", "link": "/feature_hd44780" },
- { "text": "ST7565 LCD Driver", "link": "/feature_st7565" },
- { "text": "OLED Driver", "link": "/feature_oled_driver" }
+ { "text": "HD44780 LCD Driver", "link": "/features/hd44780" },
+ { "text": "ST7565 LCD Driver", "link": "/features/st7565" },
+ { "text": "OLED Driver", "link": "/features/oled_driver" }
]
},
{
"text": "Lighting",
"items": [
- { "text": "Backlight", "link": "/feature_backlight" },
- { "text": "LED Matrix", "link": "/feature_led_matrix" },
- { "text": "RGB Lighting", "link": "/feature_rgblight" },
- { "text": "RGB Matrix", "link": "/feature_rgb_matrix" }
+ { "text": "Backlight", "link": "/features/backlight" },
+ { "text": "LED Matrix", "link": "/features/led_matrix" },
+ { "text": "RGB Lighting", "link": "/features/rgblight" },
+ { "text": "RGB Matrix", "link": "/features/rgb_matrix" }
]
},
- { "text": "Audio", "link": "/feature_audio" },
- { "text": "Bluetooth", "link": "/feature_bluetooth" },
- { "text": "Bootmagic Lite", "link": "/feature_bootmagic" },
+ { "text": "Audio", "link": "/features/audio" },
+ { "text": "Battery", "link": "/features/battery" },
+ { "text": "Bootmagic", "link": "/features/bootmagic" },
{ "text": "Converters", "link": "/feature_converters" },
{ "text": "Custom Matrix", "link": "/custom_matrix" },
- { "text": "DIP Switch", "link": "/feature_dip_switch" },
- { "text": "Encoders", "link": "/feature_encoders" },
- { "text": "Haptic Feedback", "link": "/feature_haptic_feedback" },
- { "text": "Joystick", "link": "/feature_joystick" },
- { "text": "LED Indicators", "link": "/feature_led_indicators" },
- { "text": "MIDI", "link": "/feature_midi" },
- { "text": "Pointing Device", "link": "/feature_pointing_device" },
- { "text": "PS/2 Mouse", "link": "/feature_ps2_mouse" },
- { "text": "Split Keyboard", "link": "/feature_split_keyboard" },
- { "text": "Stenography", "link": "/feature_stenography" }
+ { "text": "DIP Switch", "link": "/features/dip_switch" },
+ { "text": "Encoders", "link": "/features/encoders" },
+ { "text": "Haptic Feedback", "link": "/features/haptic_feedback" },
+ { "text": "Joystick", "link": "/features/joystick" },
+ { "text": "LED Indicators", "link": "/features/led_indicators" },
+ { "text": "MIDI", "link": "/features/midi" },
+ { "text": "Pointing Device", "link": "/features/pointing_device" },
+ { "text": "PS/2 Mouse", "link": "/features/ps2_mouse" },
+ { "text": "Split Keyboard", "link": "/features/split_keyboard" },
+ { "text": "Stenography", "link": "/features/stenography" },
+ { "text": "Wireless", "link": "/features/wireless" }
]
},
{
@@ -210,9 +214,10 @@
{ "text": "My Pull Request Was Flagged", "link": "/breaking_changes_instructions" },
{
"text": "Most Recent ChangeLog",
- "link": "/ChangeLog/20240526"
+ "link": "/ChangeLog/20250831"
},
- { "text": "Past Breaking Changes", "link": "/breaking_changes_history" }
+ { "text": "Past Breaking Changes", "link": "/breaking_changes_history" },
+ { "text": "Deprecation Policy", "link": "/support_deprecation_policy" }
]
},
@@ -226,19 +231,20 @@
"text": "Drivers",
"link": "hardware_drivers",
"items": [
- { "text": "ADC Driver", "link": "/adc_driver" },
- { "text": "APA102 Driver", "link": "/apa102_driver" },
- { "text": "Audio Driver", "link": "/audio_driver" },
- { "text": "I2C Driver", "link": "/i2c_driver" },
- { "text": "SPI Driver", "link": "/spi_driver" },
- { "text": "WS2812 Driver", "link": "/ws2812_driver" },
- { "text": "EEPROM Driver", "link": "/eeprom_driver" },
- { "text": "Flash Driver", "link": "/flash_driver" },
- { "text": "'serial' Driver", "link": "/serial_driver" },
- { "text": "UART Driver", "link": "/uart_driver" }
+ { "text": "ADC Driver", "link": "/drivers/adc" },
+ { "text": "APA102 Driver", "link": "/drivers/apa102" },
+ { "text": "Audio Driver", "link": "/drivers/audio" },
+ { "text": "Battery Driver", "link": "/drivers/battery" },
+ { "text": "EEPROM Driver", "link": "/drivers/eeprom" },
+ { "text": "Flash Driver", "link": "/drivers/flash" },
+ { "text": "I2C Driver", "link": "/drivers/i2c" },
+ { "text": "'serial' Driver", "link": "/drivers/serial" },
+ { "text": "SPI Driver", "link": "/drivers/spi" },
+ { "text": "UART Driver", "link": "/drivers/uart" },
+ { "text": "WS2812 Driver", "link": "/drivers/ws2812" }
]
},
- { "text": "GPIO Controls", "link": "/gpio_control" },
+ { "text": "GPIO Controls", "link": "/drivers/gpio" },
{ "text": "Keyboard Guidelines", "link": "/hardware_keyboard_guidelines" }
]
},
diff --git a/docs/adc_driver.md b/docs/adc_driver.md
deleted file mode 100644
index a1ab5a5251..0000000000
--- a/docs/adc_driver.md
+++ /dev/null
@@ -1,173 +0,0 @@
-# ADC Driver
-
-QMK can leverage the Analog-to-Digital Converter (ADC) on supported MCUs to measure voltages on certain pins. This can be useful for implementing things such as battery level indicators for Bluetooth keyboards, or volume controls using a potentiometer, as opposed to a [rotary encoder](feature_encoders).
-
-This driver currently supports both AVR and a limited selection of ARM devices. The values returned are 10-bit integers (0-1023) mapped between 0V and VCC (usually 5V or 3.3V for AVR, 3.3V only for ARM), however on ARM there is more flexibility in control of operation through `#define`s if you need more precision.
-
-## Usage
-
-To use this driver, add the following to your `rules.mk`:
-
-```make
-ANALOG_DRIVER_REQUIRED = yes
-```
-
-Then place this include at the top of your code:
-
-```c
-#include "analog.h"
-```
-
-## Channels
-
-### AVR
-
-|Channel|AT90USB64/128|ATmega16/32U4|ATmega32A|ATmega328/P|
-|-------|-------------|-------------|---------|----------|
-|0 |`F0` |`F0` |`A0` |`C0` |
-|1 |`F1` |`F1` |`A1` |`C1` |
-|2 |`F2` | |`A2` |`C2` |
-|3 |`F3` | |`A3` |`C3` |
-|4 |`F4` |`F4` |`A4` |`C4` |
-|5 |`F5` |`F5` |`A5` |`C5` |
-|6 |`F6` |`F6` |`A6` |* |
-|7 |`F7` |`F7` |`A7` |* |
-|8 | |`D4` | | |
-|9 | |`D6` | | |
-|10 | |`D7` | | |
-|11 | |`B4` | | |
-|12 | |`B5` | | |
-|13 | |`B6` | | |
-
-\* The ATmega328/P possesses two extra ADC channels; however, they are not present on the DIP pinout, and are not shared with GPIO pins. You can use `adc_read()` directly to gain access to these.
-
-### ARM
-
-#### STM32
-
-Note that some of these pins are doubled-up on ADCs with the same channel. This is because the pins can be used for either ADC.
-
-Also note that the F0 and F3 use different numbering schemes. The F0 has a single ADC and the channels are 0-indexed, whereas the F3 has 4 ADCs and the channels are 1-indexed. This is because the F0 uses the `ADCv1` implementation of the ADC, whereas the F3 uses the `ADCv3` implementation.
-
-|ADC|Channel|STM32F0xx|STM32F1xx|STM32F3xx|STM32F4xx|
-|---|-------|---------|---------|---------|---------|
-|1 |0 |`A0` |`A0` | |`A0` |
-|1 |1 |`A1` |`A1` |`A0` |`A1` |
-|1 |2 |`A2` |`A2` |`A1` |`A2` |
-|1 |3 |`A3` |`A3` |`A2` |`A3` |
-|1 |4 |`A4` |`A4` |`A3` |`A4` |
-|1 |5 |`A5` |`A5` |`F4` |`A5` |
-|1 |6 |`A6` |`A6` |`C0` |`A6` |
-|1 |7 |`A7` |`A7` |`C1` |`A7` |
-|1 |8 |`B0` |`B0` |`C2` |`B0` |
-|1 |9 |`B1` |`B1` |`C3` |`B1` |
-|1 |10 |`C0` |`C0` |`F2` |`C0` |
-|1 |11 |`C1` |`C1` | |`C1` |
-|1 |12 |`C2` |`C2` | |`C2` |
-|1 |13 |`C3` |`C3` | |`C3` |
-|1 |14 |`C4` |`C4` | |`C4` |
-|1 |15 |`C5` |`C5` | |`C5` |
-|1 |16 | | | | |
-|2 |0 | |`A0`¹ | |`A0`² |
-|2 |1 | |`A1`¹ |`A4` |`A1`² |
-|2 |2 | |`A2`¹ |`A5` |`A2`² |
-|2 |3 | |`A3`¹ |`A6` |`A3`² |
-|2 |4 | |`A4`¹ |`A7` |`A4`² |
-|2 |5 | |`A5`¹ |`C4` |`A5`² |
-|2 |6 | |`A6`¹ |`C0` |`A6`² |
-|2 |7 | |`A7`¹ |`C1` |`A7`² |
-|2 |8 | |`B0`¹ |`C2` |`B0`² |
-|2 |9 | |`B1`¹ |`C3` |`B1`² |
-|2 |10 | |`C0`¹ |`F2` |`C0`² |
-|2 |11 | |`C1`¹ |`C5` |`C1`² |
-|2 |12 | |`C2`¹ |`B2` |`C2`² |
-|2 |13 | |`C3`¹ | |`C3`² |
-|2 |14 | |`C4`¹ | |`C4`² |
-|2 |15 | |`C5`¹ | |`C5`² |
-|2 |16 | | | | |
-|3 |0 | |`A0`¹ | |`A0`² |
-|3 |1 | |`A1`¹ |`B1` |`A1`² |
-|3 |2 | |`A2`¹ |`E9` |`A2`² |
-|3 |3 | |`A3`¹ |`E13` |`A3`² |
-|3 |4 | |`F6`¹ | |`F6`² |
-|3 |5 | |`F7`¹ |`B13` |`F7`² |
-|3 |6 | |`F8`¹ |`E8` |`F8`² |
-|3 |7 | |`F9`¹ |`D10` |`F9`² |
-|3 |8 | |`F10`¹ |`D11` |`F10`² |
-|3 |9 | | |`D12` |`F3`² |
-|3 |10 | |`C0`¹ |`D13` |`C0`² |
-|3 |11 | |`C1`¹ |`D14` |`C1`² |
-|3 |12 | |`C2`¹ |`B0` |`C2`² |
-|3 |13 | |`C3`¹ |`E7` |`C3`² |
-|3 |14 | | |`E10` |`F4`² |
-|3 |15 | | |`E11` |`F5`² |
-|3 |16 | | |`E12` | |
-|4 |1 | | |`E14` | |
-|4 |2 | | |`E15` | |
-|4 |3 | | |`B12` | |
-|4 |4 | | |`B14` | |
-|4 |5 | | |`B15` | |
-|4 |6 | | |`E8` | |
-|4 |7 | | |`D10` | |
-|4 |8 | | |`D11` | |
-|4 |9 | | |`D12` | |
-|4 |10 | | |`D13` | |
-|4 |11 | | |`D14` | |
-|4 |12 | | |`D8` | |
-|4 |13 | | |`D9` | |
-|4 |14 | | | | |
-|4 |15 | | | | |
-|4 |16 | | | | |
-
-¹ As of ChibiOS 20.3.4, the ADC driver for STM32F1xx devices supports only ADC1, therefore any configurations involving ADC2 or ADC3 cannot actually be used. In particular, pins `F6`…`F10`, which are present at least on some STM32F103x[C-G] devices, cannot be used as ADC inputs because of this driver limitation.
-
-² Not all STM32F4xx devices have ADC2 and/or ADC3, therefore some configurations shown in this table may be unavailable; in particular, pins `F4`…`F10` cannot be used as ADC inputs on devices which do not have ADC3. Check the device datasheet to confirm which pin functions are supported.
-
-#### RP2040
-
-RP2040 has only a single ADC (`ADCD1` in ChibiOS); in the QMK API the index for that ADC is 0.
-
-|Channel|Pin |
-|-------|-------------------|
-|0 |`GP26` |
-|1 |`GP27` |
-|2 |`GP28` |
-|3 |`GP29` |
-|4 |Temperature sensor*|
-
-
-* The temperature sensor is disabled by default and needs to be enabled by the RP2040-specific function: `adcRPEnableTS(&ADCD1)`. The ADC must be initialized before calling that function; an easy way to ensure that is to perform a dummy conversion.
-
-## Functions
-
-### AVR
-
-|Function |Description |
-|----------------------------|-------------------------------------------------------------------------------------------------------------------|
-|`analogReference(mode)` |Sets the analog voltage reference source. Must be one of `ADC_REF_EXTERNAL`, `ADC_REF_POWER` or `ADC_REF_INTERNAL`.|
-|`analogReadPin(pin)` |Reads the value from the specified pin, eg. `F6` for ADC6 on the ATmega32U4. |
-|`pinToMux(pin)` |Translates a given pin to a mux value. If an unsupported pin is given, returns the mux value for "0V (GND)". |
-|`adc_read(mux)` |Reads the value from the ADC according to the specified mux. See your MCU's datasheet for more information. |
-
-### ARM
-
-|Function |Description |
-|----------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-|`analogReadPin(pin)` |Reads the value from the specified pin, eg. `A0` for channel 0 on the STM32F0 and ADC1 channel 1 on the STM32F3. Note that if a pin can be used for multiple ADCs, it will pick the lower numbered ADC for this function. eg. `C0` will be channel 6 of ADC 1 when it could be used for ADC 2 as well.|
-|`analogReadPinAdc(pin, adc)`|Reads the value from the specified pin and ADC, eg. `C0, 1` will read from channel 6, ADC 2 instead of ADC 1. Note that the ADCs are 0-indexed for this function. |
-|`pinToMux(pin)` |Translates a given pin to a channel and ADC combination. If an unsupported pin is given, returns the mux value for "0V (GND)". |
-|`adc_read(mux)` |Reads the value from the ADC according to the specified pin and ADC combination. See your MCU's datasheet for more information. |
-
-## Configuration
-
-## ARM
-
-The ARM implementation of the ADC has a few additional options that you can override in your own keyboards and keymaps to change how it operates. Please consult the corresponding `hal_adc_lld.h` in ChibiOS for your specific microcontroller for further documentation on your available options.
-
-|`#define` |Type |Default |Description |
-|---------------------|------|----------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-|`ADC_CIRCULAR_BUFFER`|`bool`|`false` |If `true`, then the implementation will use a circular buffer. |
-|`ADC_NUM_CHANNELS` |`int` |`1` |Sets the number of channels that will be scanned as part of an ADC operation. The current implementation only supports `1`. |
-|`ADC_BUFFER_DEPTH` |`int` |`2` |Sets the depth of each result. Since we are only getting a 10-bit result by default, we set this to 2 bytes so we can contain our one value. This could be set to 1 if you opt for an 8-bit or lower result.|
-|`ADC_SAMPLING_RATE` |`int` |`ADC_SMPR_SMP_1P5` |Sets the sampling rate of the ADC. By default, it is set to the fastest setting. |
-|`ADC_RESOLUTION` |`int` |`ADC_CFGR1_RES_10BIT` or `ADC_CFGR_RES_10BITS`|The resolution of your result. We choose 10 bit by default, but you can opt for 12, 10, 8, or 6 bit. Different MCUs use slightly different names for the resolution constants. |
diff --git a/docs/apa102_driver.md b/docs/apa102_driver.md
deleted file mode 100644
index 0f905e3f18..0000000000
--- a/docs/apa102_driver.md
+++ /dev/null
@@ -1,49 +0,0 @@
-# APA102 Driver {#apa102-driver}
-
-This driver provides support for APA102 addressable RGB LEDs. They are similar to the [WS2812](ws2812_driver) LEDs, but have increased data and refresh rates.
-
-## Usage {#usage}
-
-In most cases, the APA102 driver code is automatically included if you are using either the [RGBLight](feature_rgblight) or [RGB Matrix](feature_rgb_matrix) feature with the `apa102` driver set, and you would use those APIs instead.
-
-However, if you need to use the driver standalone, add the following to your `rules.mk`:
-
-```make
-APA102_DRIVER_REQUIRED = yes
-```
-
-You can then call the APA102 API by including `apa102.h` in your code.
-
-## Basic Configuration {#basic-configuration}
-
-Add the following to your `config.h`:
-
-|Define |Default |Description |
-|---------------------------|-------------|------------------------------------------------------------------|
-|`APA102_DI_PIN` |*Not defined*|The GPIO pin connected to the DI pin of the first LED in the chain|
-|`APA102_CI_PIN` |*Not defined*|The GPIO pin connected to the CI pin of the first LED in the chain|
-|`APA102_DEFAULT_BRIGHTNESS`|`31` |The default global brightness level of the LEDs, from 0 to 31 |
-
-## API {#api}
-
-### `void apa102_setleds(rgb_led_t *start_led, uint16_t num_leds)`
-
-Send RGB data to the APA102 LED chain.
-
-#### Arguments {#api-apa102-setleds-arguments}
-
- - `rgb_led_t *start_led`
- A pointer to the LED array.
- - `uint16_t num_leds`
- The length of the LED array.
-
----
-
-### `void apa102_set_brightness(uint8_t brightness)`
-
-Set the global brightness.
-
-#### Arguments {#api-apa102-set-brightness-arguments}
-
- - `uint8_t brightness`
- The brightness level to set, from 0 to 31.
diff --git a/docs/api_development_overview.md b/docs/api_development_overview.md
index e55d034100..eb164bec52 100644
--- a/docs/api_development_overview.md
+++ b/docs/api_development_overview.md
@@ -4,7 +4,7 @@ This page attempts to introduce developers to the QMK Compiler. It does not go i
# Overview
-The QMK Compile API consists of a few movings parts:
+The QMK Compile API consists of a few moving parts:
diff --git a/docs/audio_driver.md b/docs/audio_driver.md
deleted file mode 100644
index 4a71b4f411..0000000000
--- a/docs/audio_driver.md
+++ /dev/null
@@ -1,239 +0,0 @@
-# Audio Driver {#audio-driver}
-
-The [Audio feature](feature_audio) breaks the hardware specifics out into separate, exchangeable driver units, with a common interface to the audio-"core" - which itself handles playing songs and notes while tracking their progress in an internal state, initializing/starting/stopping the driver as needed.
-
-Not all MCUs support every available driver, either the platform-support is not there (yet?) or the MCU simply does not have the required hardware peripheral.
-
-
-## AVR {#avr}
-
-Boards built around an Atmega32U4 can use two sets of PWM capable pins, each driving a separate speaker.
-The possible configurations are:
-
-| | Timer3 | Timer1 |
-|--------------|-------------|--------------|
-| one speaker | C4,C5 or C6 | |
-| one speaker | | B4, B5 or B7 |
-| two speakers | C4,C5 or C6 | B4, B5 or B7 |
-
-Currently there is only one/default driver for AVR based boards, which is automatically configured to:
-
-```make
-AUDIO_DRIVER = pwm_hardware
-```
-
-
-## ARM {#arm}
-
-For Arm based boards, QMK depends on ChibiOS - hence any MCU supported by the later is likely usable, as long as certain hardware peripherals are available.
-
-Supported wiring configurations, with their ChibiOS/MCU peripheral requirement are listed below;
-piezo speakers are marked with :one: for the first/primary and :two: for the secondary.
-
- | driver | GPTD6Tim6 | GPTD7
Tim7 | GPTD8
Tim8 | PWMD11
Tim1_Ch1 | - |--------------|------------------------------------------|------------------------|---------------|-------------------------------| - | dac_basic | A4+DACD1 = :one: | A5+DACD2 = :one: | state | | - | | A4+DACD1 = :one: + Gnd | A5+DACD2 = :two: + Gnd | state | | - | | A4+DACD1 = :two: + Gnd | A5+DACD2 = :one: + Gnd | state | | - | | A4+DACD1 = :one: + Gnd | | state | | - | | | A5+DACD2 = :one: + Gnd | state | | - | dac_additive | A4+DACD1 = :one: + Gnd | | | | - | | A5+DACD2 = :one: + Gnd | | | | - | | A4+DACD1 + A5+DACD2 = :one: 2 | | | | - | pwm_software | state-update | | | any = :one: | - | pwm hardware | state-update | | | A8 = :one: 3 | - - -1: the routing and alternate functions for PWM differ sometimes between STM32 MCUs, if in doubt consult the data-sheet -2: one piezo connected to A4 and A5, with AUDIO_PIN_ALT_AS_NEGATIVE set -3: TIM1_CH1 = A8 on STM32F103C8, other combinations are possible, see Data-sheet. configured with: AUDIO_PWM_DRIVER and AUDIO_PWM_CHANNEL - - - -### DAC basic {#dac-basic} - -The default driver for ARM boards, in absence of an overriding configuration. -This driver needs one Timer per enabled/used DAC channel, to trigger conversion; and a third timer to trigger state updates with the audio-core. - -Additionally, in the board config, you'll want to make changes to enable the DACs, GPT for Timers 6, 7 and 8: - -```c -//halconf.h: -#define HAL_USE_DAC TRUE -#define HAL_USE_GPT TRUE -#include_next
Tim6 | GPTD7
Tim7 | GPTD8
Tim8 | PWMD11
Tim1_Ch1 | + |--------------|------------------------------------------|------------------------|---------------|-------------------------------| + | dac_basic | A4+DACD1 = :one: | A5+DACD2 = :one: | state | | + | | A4+DACD1 = :one: + Gnd | A5+DACD2 = :two: + Gnd | state | | + | | A4+DACD1 = :two: + Gnd | A5+DACD2 = :one: + Gnd | state | | + | | A4+DACD1 = :one: + Gnd | | state | | + | | | A5+DACD2 = :one: + Gnd | state | | + | dac_additive | A4+DACD1 = :one: + Gnd | | | | + | | A5+DACD2 = :one: + Gnd | | | | + | | A4+DACD1 + A5+DACD2 = :one: 2 | | | | + | pwm_software | state-update | | | any = :one: | + | pwm hardware | state-update | | | A8 = :one: 3 | + + +1: the routing and alternate functions for PWM differ sometimes between STM32 MCUs, if in doubt consult the data-sheet +2: one piezo connected to A4 and A5, with AUDIO_PIN_ALT_AS_NEGATIVE set +3: TIM1_CH1 = A8 on STM32F103C8, other combinations are possible, see Data-sheet. configured with: AUDIO_PWM_DRIVER and AUDIO_PWM_CHANNEL + + + +### DAC basic {#dac-basic} + +The default driver for ARM boards, in absence of an overriding configuration. +This driver needs one Timer per enabled/used DAC channel, to trigger conversion; and a third timer to trigger state updates with the audio-core. + +Additionally, in the board config, you'll want to make changes to enable the DACs, GPT for Timers 6, 7 and 8: + +::: code-group +```c [halconf.h] +#pragma once + +#define HAL_USE_DAC TRUE // [!code focus] +#define HAL_USE_GPT TRUE // [!code focus] + +#include_next
` on a Single Key
-See the [Grave Escape](feature_grave_esc) feature.
+See the [Grave Escape](features/grave_esc) feature.
## Eject on Mac OSX
diff --git a/docs/feature_advanced_keycodes.md b/docs/feature_advanced_keycodes.md
index 50dc0bb281..a6f8bc8372 100644
--- a/docs/feature_advanced_keycodes.md
+++ b/docs/feature_advanced_keycodes.md
@@ -2,29 +2,40 @@
These allow you to combine a modifier with a keycode. When pressed, the keydown event for the modifier, then `kc` will be sent. On release, the keyup event for `kc`, then the modifier will be sent.
-|Key |Aliases |Description |
-|----------|----------------------------------|------------------------------------------------------|
-|`LCTL(kc)`|`C(kc)` |Hold Left Control and press `kc` |
-|`LSFT(kc)`|`S(kc)` |Hold Left Shift and press `kc` |
-|`LALT(kc)`|`A(kc)`, `LOPT(kc)` |Hold Left Alt and press `kc` |
-|`LGUI(kc)`|`G(kc)`, `LCMD(kc)`, `LWIN(kc)` |Hold Left GUI and press `kc` |
-|`RCTL(kc)`| |Hold Right Control and press `kc` |
-|`RSFT(kc)`| |Hold Right Shift and press `kc` |
-|`RALT(kc)`|`ROPT(kc)`, `ALGR(kc)` |Hold Right Alt and press `kc` |
-|`RGUI(kc)`|`RCMD(kc)`, `LWIN(kc)` |Hold Right GUI and press `kc` |
-|`LSG(kc)` |`SGUI(kc)`, `SCMD(kc)`, `SWIN(kc)`|Hold Left Shift and GUI and press `kc` |
-|`LAG(kc)` | |Hold Left Alt and Left GUI and press `kc` |
-|`RSG(kc)` | |Hold Right Shift and Right GUI and press `kc` |
-|`RAG(kc)` | |Hold Right Alt and Right GUI and press `kc` |
-|`LCA(kc)` | |Hold Left Control and Alt and press `kc` |
-|`LSA(kc)` | |Hold Left Shift and Left Alt and press `kc` |
-|`RSA(kc)` |`SAGR(kc)` |Hold Right Shift and Right Alt (AltGr) and press `kc` |
-|`RCS(kc)` | |Hold Right Control and Right Shift and press `kc` |
-|`LCAG(kc)`| |Hold Left Control, Alt and GUI and press `kc` |
-|`MEH(kc)` | |Hold Left Control, Shift and Alt and press `kc` |
-|`HYPR(kc)`| |Hold Left Control, Shift, Alt and GUI and press `kc` |
+|Key |Aliases |Description |
+|----------|-------------------------------|-------------------------------------------------------------------------------|
+|`LCTL(kc)`|`C(kc)` |Hold Left Control and press `kc` |
+|`LSFT(kc)`|`S(kc)` |Hold Left Shift and press `kc` |
+|`LALT(kc)`|`A(kc)`, `LOPT(kc)` |Hold Left Alt and press `kc` |
+|`LGUI(kc)`|`G(kc)`, `LCMD(kc)`, `LWIN(kc)`|Hold Left GUI and press `kc` |
+|`LCS(kc)` | |Hold Left Control and Left Shift and press `kc` |
+|`LCA(kc)` | |Hold Left Control and Left Alt and press `kc` |
+|`LCG(kc)` | |Hold Left Control and Left GUI and press `kc` |
+|`LSA(kc)` | |Hold Left Shift and Left Alt and press `kc` |
+|`LSG(kc)` | |Hold Left Shift and Left GUI and press `kc` |
+|`LAG(kc)` | |Hold Left Alt and Left GUI and press `kc` |
+|`LCSG(kc)`| |Hold Left Control, Left Shift and Left GUI and press `kc` |
+|`LCAG(kc)`| |Hold Left Control, Left Alt and Left GUI and press `kc` |
+|`LSAG(kc)`| |Hold Left Shift, Left Alt and Left GUI and press `kc` |
+|`RCTL(kc)`| |Hold Right Control and press `kc` |
+|`RSFT(kc)`| |Hold Right Shift and press `kc` |
+|`RALT(kc)`|`ROPT(kc)`, `ALGR(kc)` |Hold Right Alt and press `kc` |
+|`RGUI(kc)`|`RCMD(kc)`, `RWIN(kc)` |Hold Right GUI and press `kc` |
+|`RCA(kc)` | |Hold Right Control and Right Alt and press `kc` |
+|`RCS(kc)` | |Hold Right Control and Right Shift and press `kc` |
+|`RCG(kc)` | |Hold Right Control and Right GUI and press `kc` |
+|`RSA(kc)` | |Hold Right Shift and Right Alt and press `kc` |
+|`RSG(kc)` | |Hold Right Shift and Right GUI and press `kc` |
+|`RAG(kc)` | |Hold Right Alt and Right GUI and press `kc` |
+|`RCSG(kc)`| |Hold Right Control, Right Shift and Right GUI and press `kc` |
+|`RCAG(kc)`| |Hold Right Control, Right Alt and Right GUI and press `kc` |
+|`RSAG(kc)`| |Hold Right Shift, Right Alt and Right GUI and press `kc` |
+|`MEH(kc)` | |Hold Left Control, Left Shift and Left Alt and press `kc` |
+|`HYPR(kc)`| |Hold Left Control, Left Shift, Left Alt and Left GUI and press `kc`1|
-You can also chain them, for example `LCTL(LALT(KC_DEL))` or `C(A(KC_DEL))` makes a key that sends Control+Alt+Delete with a single keypress.
+1. More information on the Hyper key can be found on [this blog post by Brett Terpstra](https://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/).
+
+You can also chain them, for example `LCTL(LALT(KC_DEL))`, `C(A(KC_DEL))`, or `LCA(KC_DEL)` all make a key that sends Control+Alt+Delete with a single keypress.
# Checking Modifier State {#checking-modifier-state}
@@ -160,7 +171,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
return true;
};
```
-Alternatively, this can be done with [Key Overrides](feature_key_overrides#simple-example).
+Alternatively, this can be done with [Key Overrides](features/key_overrides#simple-example).
# Advanced topics {#advanced-topics}
@@ -184,4 +195,4 @@ This page used to encompass a large set of features. We have moved many sections
## Key Overrides {#key-overrides}
-* [Key Overrides](feature_key_overrides)
+* [Key Overrides](features/key_overrides)
diff --git a/docs/feature_audio.md b/docs/feature_audio.md
deleted file mode 100644
index ec28860ae9..0000000000
--- a/docs/feature_audio.md
+++ /dev/null
@@ -1,377 +0,0 @@
-# Audio
-
-Your keyboard can make sounds! If you've got a spare pin 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.
-
-To activate this feature, add `AUDIO_ENABLE = yes` to your `rules.mk`.
-
-## AVR based boards
-On Atmega32U4 based boards, up to two simultaneous tones can be rendered.
-With one speaker connected to a PWM capable pin on PORTC driven by timer 3 and the other on one of the PWM pins on PORTB driven by timer 1.
-
-The following pins can be configured as audio outputs in `config.h` - for one speaker set either one out of:
-
-* `#define AUDIO_PIN C4`
-* `#define AUDIO_PIN C5`
-* `#define AUDIO_PIN C6`
-* `#define AUDIO_PIN B5`
-* `#define AUDIO_PIN B6`
-* `#define AUDIO_PIN B7`
-
-and *optionally*, for a second speaker, one of:
-* `#define AUDIO_PIN_ALT B5`
-* `#define AUDIO_PIN_ALT B6`
-* `#define AUDIO_PIN_ALT B7`
-
-### Wiring
-per speaker is - for example with a piezo buzzer - the black lead to Ground, and the red lead connected to the selected AUDIO_PIN for the primary; and similarly with AUDIO_PIN_ALT for the secondary.
-
-
-## ARM based boards
-for more technical details, see the notes on [Audio driver](audio_driver).
-
-
-### DAC (basic)
-Most STM32 MCUs have DAC peripherals, with a notable exception of the STM32F1xx series. Generally, the DAC peripheral drives pins A4 or A5. To enable DAC-based audio output on STM32 devices, add `AUDIO_DRIVER = dac_basic` to `rules.mk` and set in `config.h` either:
-
-`#define AUDIO_PIN A4` or `#define AUDIO_PIN A5`
-
-the other DAC channel can optionally be used with a secondary speaker, just set:
-
-`#define AUDIO_PIN_ALT A4` or `#define AUDIO_PIN_ALT A5`
-
-Do note though that the dac_basic driver is only capable of reproducing one tone per speaker/channel at a time, for more tones simultaneously, try the dac_additive driver.
-
-#### Wiring:
-for two piezos, for example configured as `AUDIO_PIN A4` and `AUDIO_PIN_ALT A5` would be: red lead to A4 and black to Ground, and similarly with the second one: A5 = red, and Ground = black
-
-another alternative is to drive *one* piezo with both DAC pins - for an extra "push".
-wiring red to A4 and black to A5 (or the other way round) and add `#define AUDIO_PIN_ALT_AS_NEGATIVE` to `config.h`
-
-##### Proton-C Example:
-The Proton-C comes (optionally) with one 'builtin' piezo, which is wired to A4+A5.
-For this board `config.h` would include these defines:
-
-```c
-#define AUDIO_PIN A5
-#define AUDIO_PIN_ALT A4
-#define AUDIO_PIN_ALT_AS_NEGATIVE
-```
-
-### DAC (additive)
-Another option, besides dac_basic (which produces sound through a square-wave), is to use the DAC to do additive wave synthesis.
-With a number of predefined wave-forms or by providing your own implementation to generate samples on the fly.
-To use this feature set `AUDIO_DRIVER = dac_additive` in your `rules.mk`, and select in `config.h` EITHER `#define AUDIO_PIN A4` or `#define AUDIO_PIN A5`.
-
-The used waveform *defaults* to sine, but others can be selected by adding one of the following defines to `config.h`:
-
-* `#define AUDIO_DAC_SAMPLE_WAVEFORM_SINE`
-* `#define AUDIO_DAC_SAMPLE_WAVEFORM_TRIANGLE`
-* `#define AUDIO_DAC_SAMPLE_WAVEFORM_TRAPEZOID`
-* `#define AUDIO_DAC_SAMPLE_WAVEFORM_SQUARE`
-
-Should you rather choose to generate and use your own sample-table with the DAC unit, implement `uint16_t dac_value_generate(void)` with your keyboard - for an example implementation see keyboards/planck/keymaps/synth_sample or keyboards/planck/keymaps/synth_wavetable
-
-
-### PWM (software)
-if the DAC pins are unavailable (or the MCU has no usable DAC at all, like STM32F1xx); PWM can be an alternative.
-Note that there is currently only one speaker/pin supported.
-
-set in `rules.mk`:
-
-`AUDIO_DRIVER = pwm_software` and in `config.h`:
-`#define AUDIO_PIN C13` (can be any pin) to have the selected pin output a pwm signal, generated from a timer callback which toggles the pin in software.
-
-#### Wiring
-the usual piezo wiring: red goes to the selected AUDIO_PIN, black goes to ground.
-
-OR if you can chose to drive one piezo with two pins, for example `#define AUDIO_PIN B1`, `#define AUDIO_PIN_ALT B2` in `config.h`, with `#define AUDIO_PIN_ALT_AS_NEGATIVE` - then the red lead could go to B1, the black to B2.
-
-### PWM (hardware)
-STM32F1xx have to fall back to using PWM, but can do so in hardware; but again on currently only one speaker/pin.
-
-`AUDIO_DRIVER = pwm_hardware` in `rules.mk`, and in `config.h`:
-`#define AUDIO_PIN A8`
-`#define AUDIO_PWM_DRIVER PWMD1`
-`#define AUDIO_PWM_CHANNEL 1`
-(as well as `#define AUDIO_PWM_PAL_MODE 42` if you are on STM32F2 or larger)
-which will use Timer 1 to directly drive pin PA8 through the PWM hardware (TIM1_CH1 = PA8).
-Should you want to use the pwm-hardware on another pin and timer - be ready to dig into the STM32 data-sheet to pick the right TIMx_CHy and pin-alternate function.
-
-
-## Tone Multiplexing
-Since most drivers can only render one tone per speaker at a time (with the one exception: arm dac-additive) there also exists a "workaround-feature" that does time-slicing/multiplexing - which does what the name implies: cycle through a set of active tones (e.g. when playing chords in Music Mode) at a given rate, and put one tone at a time out through the one/few speakers that are available.
-
-To enable this feature, and configure a starting-rate, add the following defines to `config.h`:
-```c
-#define AUDIO_ENABLE_TONE_MULTIPLEXING
-#define AUDIO_TONE_MULTIPLEXING_RATE_DEFAULT 10
-```
-
-The audio core offers interface functions to get/set/change the tone multiplexing rate from within `keymap.c`.
-
-
-## Songs
-There's a couple of 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 QK_BOOT 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)
-CG_NORM_SONG // plays when you press CG_NORM (quantum.c)
-CG_SWAP_SONG // plays when you press CG_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).
-
-Additionally, if you with to maintain your own list of songs (such as ones that may be copyrighted) and not have them added to the repo, you can create a `user_song_list.h` file and place it in your keymap (or userspace) folder. This file will be automatically included, it just needs to exist.
-
-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:
-
-|Key |Aliases |Description |
-|-------------------------|---------|-------------------------------------------|
-|`QK_AUDIO_ON` |`AU_ON` |Turns on Audio Feature |
-|`QK_AUDIO_OFF` |`AU_OFF` |Turns off Audio Feature |
-|`QK_AUDIO_TOGGLE` |`AU_TOGG`|Toggles Audio state |
-
-::: warning
-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.
-:::
-
-## Audio Config
-
-| Settings | Default | Description |
-|----------------------------------|----------------------|---------------------------------------------------------------------------------------------|
-|`AUDIO_PIN` | *Not defined* |Configures the pin that the speaker is connected to. |
-|`AUDIO_PIN_ALT` | *Not defined* |Configures the pin for a second speaker or second pin connected to one speaker. |
-|`AUDIO_PIN_ALT_AS_NEGATIVE` | *Not defined* |Enables support for one speaker connected to two pins. |
-|`AUDIO_INIT_DELAY` | *Not defined* |Enables delay during startup song to accomidate for USB startup issues. |
-|`AUDIO_ENABLE_TONE_MULTIPLEXING` | *Not defined* |Enables time splicing/multiplexing to create multiple tones simutaneously. |
-|`AUDIO_POWER_CONTROL_PIN` | *Not defined* |Enables power control code to enable or cut off power to speaker (such as with PAM8302 amp). |
-|`AUDIO_POWER_CONTROL_PIN_ON_STATE`| `1` |The state of the audio power control pin when audio is "on" - `1` for high, `0` for low. |
-|`STARTUP_SONG` | `STARTUP_SOUND` |Plays when the keyboard starts up (audio.c) |
-|`GOODBYE_SONG` | `GOODBYE_SOUND` |Plays when you press the QK_BOOT key (quantum.c) |
-|`AG_NORM_SONG` | `AG_NORM_SOUND` |Plays when you press AG_NORM (process_magic.c) |
-|`AG_SWAP_SONG` | `AG_SWAP_SOUND` |Plays when you press AG_SWAP (process_magic.c) |
-|`CG_NORM_SONG` | `AG_NORM_SOUND` |Plays when you press CG_NORM (process_magic.c) |
-|`CG_SWAP_SONG` | `AG_SWAP_SOUND` |Plays when you press CG_SWAP (process_magic.c) |
-|`MUSIC_ON_SONG` | `MUSIC_ON_SOUND` |Plays when music mode is activated (process_music.c) |
-|`MUSIC_OFF_SONG` | `MUSIC_OFF_SOUND` |Plays when music mode is deactivated (process_music.c) |
-|`MIDI_ON_SONG` | `MUSIC_ON_SOUND` |Plays when midi mode is activated (process_music.c) |
-|`MIDI_OFF_SONG` | `MUSIC_OFF_SOUND` |Plays when midi mode is deactivated (process_music.c) |
-|`CHROMATIC_SONG` | `CHROMATIC_SOUND` |Plays when the chromatic music mode is selected (process_music.c) |
-|`GUITAR_SONG` | `GUITAR_SOUND` |Plays when the guitar music mode is selected (process_music.c) |
-|`VIOLIN_SONG` | `VIOLIN_SOUND` |Plays when the violin music mode is selected (process_music.c) |
-|`MAJOR_SONG` | `MAJOR_SOUND` |Plays when the major music mode is selected (process_music.c) |
-|`DEFAULT_LAYER_SONGS` | *Not defined* |Plays song when switched default layers with [`set_single_persistent_default_layer(layer)`](ref_functions.md#setting-the-persistent-default-layer)(quantum.c). |
-|`SENDSTRING_BELL` | *Not defined* |Plays chime when the "enter" ("\a") character is sent (send_string.c) |
-
-## Tempo
-the 'speed' at which SONGs are played is dictated by the set Tempo, which is measured in beats-per-minute. Note lengths are defined relative to that.
-The initial/default tempo is set to 120 bpm, but can be configured by setting `TEMPO_DEFAULT` in `config.c`.
-There is also a set of functions to modify the tempo from within the user/keymap code:
-```c
-void audio_set_tempo(uint8_t tempo);
-void audio_increase_tempo(uint8_t tempo_change);
-void audio_decrease_tempo(uint8_t tempo_change);
-```
-
-## 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 `AUDIO_DAC_SAMPLE_MAX` in your `config.h`:
-
-```c
-#define AUDIO_DAC_SAMPLE_MAX 4095U
-```
-the DAC usually runs in 12Bit mode, hence a volume of 100% = 4095U
-
-Note: this only adjusts the volume aka 'works' if you stick to WAVEFORM_SQUARE, since its samples are generated on the fly - any other waveform uses a hardcoded/precomputed sample-buffer.
-
-## Voices
-Aka "audio effects", different ones can be enabled by setting in `config.h` these defines:
-`#define AUDIO_VOICES` to enable the feature, and `#define AUDIO_VOICE_DEFAULT something` to select a specific effect
-for details see quantum/audio/voices.h and .c
-
-Keycodes available:
-
-|Key |Aliases |Description |
-|-------------------------|---------|-------------------------------------------|
-|`QK_AUDIO_VOICE_NEXT` |`AU_NEXT`|Cycles through the audio voices |
-|`QK_AUDIO_VOICE_PREVIOUS`|`AU_PREV`|Cycles through the audio voices in reverse |
-
-## 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:
-
-|Key |Aliases |Description |
-|-------------------------|---------|-------------------------------------------|
-|`QK_MUSIC_ON` |`MU_ON` |Turns on Music Mode |
-|`QK_MUSIC_OFF` |`MU_OFF` |Turns off Music Mode |
-|`QK_MUSIC_TOGGLE` |`MU_TOGG`|Toggles Music Mode |
-|`QK_MUSIC_MODE_NEXT` |`MU_NEXT`|Cycles through the music modes |
-
-Available 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`:
-
-```c
-#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`:
-
-```c
-#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:
-
-```c
-#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 `
-
-By defining `RGBLIGHT_LED_MAP` as in the example below, you can specify the LED with addressing in reverse order of the electrical connection order.
-
-```c
-// config.h
-
-#define RGBLIGHT_LED_COUNT 4
-#define RGBLIGHT_LED_MAP { 3, 2, 1, 0 }
-
-```
-
-
-## Clipping Range
-
-Using the `rgblight_set_clipping_range()` function, you can prepare more buffers than the actual number of LEDs, and output some of the buffers to the LEDs. This is useful if you want the split keyboard to treat left and right LEDs as logically contiguous.
-
-You can set the Clipping Range by executing the following code.
-
-```c
-// some source
-rgblight_set_clipping_range(3, 4);
-```
-
-
-In addition to setting the Clipping Range, you can use `RGBLIGHT_LED_MAP` together.
-
-```c
-// config.h
-#define RGBLIGHT_LED_COUNT 8
-#define RGBLIGHT_LED_MAP { 7, 6, 5, 4, 3, 2, 1, 0 }
-
-// some source
-rgblight_set_clipping_range(3, 4);
-```
-
-
-## Hardware Modification
-
-If your keyboard lacks onboard underglow LEDs, you may often be able to solder on an RGB LED strip yourself. You will need to find an unused pin to wire to the data pin of your LED strip. Some keyboards may break out unused pins from the MCU to make soldering easier. The other two pins, VCC and GND, must also be connected to the appropriate power pins.
-
-## Velocikey
-
-Velocikey is a feature that lets you control the speed of lighting effects (like the Rainbow Swirl effect) with the speed of your typing. The faster you type, the faster the lights will go!
-
-### Usage
-For Velocikey to take effect, there are two steps. First, when compiling your keyboard, you'll need to set `VELOCIKEY_ENABLE=yes` in `rules.mk`, e.g.:
-
-```
-MOUSEKEY_ENABLE = no
-STENO_ENABLE = no
-EXTRAKEY_ENABLE = yes
-VELOCIKEY_ENABLE = yes
-```
-
-Then, while using your keyboard, you need to also turn it on with the `VK_TOGG` keycode, which toggles the feature on and off.
-
-The following light effects will all be controlled by Velocikey when it is enabled:
- - RGB Breathing
- - RGB Rainbow Mood
- - RGB Rainbow Swirl
- - RGB Snake
- - RGB Knight
-
-Support for LED breathing effects is planned but not available yet.
-
- As long as Velocikey is enabled, it will control the speed regardless of any other speed setting that your RGB lights are currently on.
-
- ### Configuration
- Velocikey doesn't currently support any configuration via keyboard settings. If you want to adjust something like the speed increase or decay rate, you would need to edit `velocikey.c` and adjust the values there to achieve the kinds of speeds that you like.
diff --git a/docs/feature_secure.md b/docs/feature_secure.md
deleted file mode 100644
index 5ca9eed65f..0000000000
--- a/docs/feature_secure.md
+++ /dev/null
@@ -1,56 +0,0 @@
-# Secure
-
-The secure feature aims to prevent unwanted interaction without user intervention.
-
-::: tip
-Secure does **not** currently implement encryption/decryption/etc and should not be a replacement where a strong hardware/software based solution is required.
-:::
-
-### Unlock sequence
-
-To unlock, the user must perform a set of actions. This can optionally be configured to be multiple keys.
-
-* While unlocking all keyboard input is ignored
-* Incorrect attempts will revert back to the previously locked state
-
-### Automatic Locking
-
-Once unlocked, the keyboard will revert back to a locked state after the configured timeout.
-The timeout can be refreshed by using the `secure_activity_event` function, for example from one of the various [hooks](custom_quantum_functions).
-
-## Usage
-
-Add the following to your `rules.mk`:
-
-```make
-SECURE_ENABLE = yes
-```
-
-## Keycodes
-
-| Key |Aliases | Description |
-|---------------------|---------|--------------------------------------------------------------------------------|
-| `QK_SECURE_LOCK` |`SE_LOCK`| Revert back to a locked state |
-| `QK_SECURE_UNLOCK` |`SE_UNLK`| Forces unlock without performing a unlock sequence |
-| `QK_SECURE_TOGGLE` |`SE_TOGG`| Toggle directly between locked and unlock without performing a unlock sequence |
-| `QK_SECURE_REQUEST` |`SE_REQ` | Request that user perform the unlock sequence |
-
-## Configuration
-
-| Define | Default | Description |
-|-------------------------|----------------|---------------------------------------------------------------------------------|
-|`SECURE_UNLOCK_TIMEOUT` | `5000` | Timeout for the user to perform the configured unlock sequence - `0` to disable |
-|`SECURE_IDLE_TIMEOUT` | `60000` | Timeout while unlocked before returning to locked - `0` to disable |
-|`SECURE_UNLOCK_SEQUENCE` | `{ { 0, 0 } }` | Array of matrix locations describing a sequential sequence of keypresses |
-
-## Functions
-
-| Function | Description |
-|---------------------------|----------------------------------------------------------------------------|
-| `secure_is_locked()` | Check if the device is currently locked |
-| `secure_is_unlocking()` | Check if an unlock sequence is currently in progress |
-| `secure_is_unlocked()` | Check if the device is currently unlocked |
-| `secure_lock()` | Lock down the device |
-| `secure_unlock()` | Force unlock the device - bypasses user unlock sequence |
-| `secure_request_unlock()` | Begin listening for an unlock sequence |
-| `secure_activity_event()` | Flag that user activity has happened and the device should remain unlocked |
diff --git a/docs/feature_send_string.md b/docs/feature_send_string.md
deleted file mode 100644
index 97e4ccc809..0000000000
--- a/docs/feature_send_string.md
+++ /dev/null
@@ -1,226 +0,0 @@
-# Send String {#send-string}
-
-The Send String API is part of QMK's macro system. It allows for sequences of keystrokes to be sent automatically.
-
-The full ASCII character set is supported, along with all of the keycodes in the Basic Keycode range (as these are the only ones that will actually be sent to the host).
-
-::: tip
-Unicode characters are **not** supported with this API -- see the [Unicode](feature_unicode) feature instead.
-:::
-
-## Usage {#usage}
-
-Send String is enabled by default, so there is usually no need for any special setup. However, if it is disabled, add the following to your `rules.mk`:
-
-```make
-SEND_STRING_ENABLE = yes
-```
-
-## Basic Configuration {#basic-configuration}
-
-Add the following to your `config.h`:
-
-|Define |Default |Description |
-|-----------------|----------------|------------------------------------------------------------------------------------------------------------|
-|`SENDSTRING_BELL`|*Not defined* |If the [Audio](feature_audio) feature is enabled, the `\a` character (ASCII `BEL`) will beep the speaker.|
-|`BELL_SOUND` |`TERMINAL_SOUND`|The song to play when the `\a` character is encountered. By default, this is an eighth note of C5. |
-
-## Keycodes {#keycodes}
-
-The Send String functions accept C string literals, but specific keycodes can be injected with the below macros. All of the keycodes in the [Basic Keycode range](keycodes_basic) are supported (as these are the only ones that will actually be sent to the host), but with an `X_` prefix instead of `KC_`.
-
-|Macro |Description |
-|--------------|-------------------------------------------------------------------|
-|`SS_TAP(x)` |Send a keydown, then keyup, event for the given Send String keycode|
-|`SS_DOWN(x)` |Send a keydown event for the given Send String keycode |
-|`SS_UP(x)` |Send a keyup event for the given Send String keycode |
-|`SS_DELAY(ms)`|Wait for `ms` milliseconds |
-
-The following characters are also mapped to their respective keycodes for convenience:
-
-|Character|Hex |ASCII|Keycode |
-|---------|------|-----|--------------|
-|`\b` |`\x08`|`BS` |`KC_BACKSPACE`|
-|`\e` |`\x09`|`ESC`|`KC_ESCAPE` |
-|`\n` |`\x0A`|`LF` |`KC_ENTER` |
-|`\t` |`\x1B`|`TAB`|`KC_TAB` |
-| |`\x7F`|`DEL`|`KC_DELETE` |
-
-### Language Support {#language-support}
-
-By default, Send String assumes your OS keyboard layout is set to US ANSI. If you are using a different keyboard layout, you can [override the lookup tables used to convert ASCII characters to keystrokes](reference_keymap_extras#sendstring-support).
-
-## Examples {#examples}
-
-### Hello World {#example-hello-world}
-
-A simple custom keycode which types out "Hello, world!" and the Enter key when pressed.
-
-Add the following to your `keymap.c`:
-
-```c
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
- switch (keycode) {
- case SS_HELLO:
- if (record->event.pressed) {
- SEND_STRING("Hello, world!\n");
- }
- return false;
- }
-
- return true;
-}
-```
-
-### Keycode Injection {#example-keycode-injection}
-
-This example types out opening and closing curly braces, then taps the left arrow key to move the cursor between the two.
-
-```c
-SEND_STRING("{}" SS_TAP(X_LEFT));
-```
-
-This example types Ctrl+A, then Ctrl+C, without releasing Ctrl.
-
-```c
-SEND_STRING(SS_LCTL("ac"));
-```
-
-## API {#api}
-
-### `void send_string(const char *string)` {#api-send-string}
-
-Type out a string of ASCII characters.
-
-This function simply calls `send_string_with_delay(string, 0)`.
-
-#### Arguments {#api-send-string-arguments}
-
- - `const char *string`
- The string to type out.
-
----
-
-### `void send_string_with_delay(const char *string, uint8_t interval)` {#api-send-string-with-delay}
-
-Type out a string of ASCII characters, with a delay between each character.
-
-#### Arguments {#api-send-string-with-delay-arguments}
-
- - `const char *string`
- The string to type out.
- - `uint8_t interval`
- The amount of time, in milliseconds, to wait before typing the next character.
-
----
-
-### `void send_string_P(const char *string)` {#api-send-string-p}
-
-Type out a PROGMEM string of ASCII characters.
-
-On ARM devices, this function is simply an alias for `send_string_with_delay(string, 0)`.
-
-#### Arguments {#api-send-string-p-arguments}
-
- - `const char *string`
- The string to type out.
-
----
-
-### `void send_string_with_delay_P(const char *string, uint8_t interval)` {#api-send-string-with-delay-p}
-
-Type out a PROGMEM string of ASCII characters, with a delay between each character.
-
-On ARM devices, this function is simply an alias for `send_string_with_delay(string, interval)`.
-
-#### Arguments {#api-send-string-with-delay-p-arguments}
-
- - `const char *string`
- The string to type out.
- - `uint8_t interval`
- The amount of time, in milliseconds, to wait before typing the next character.
-
----
-
-### `void send_char(char ascii_code)` {#api-send-char}
-
-Type out an ASCII character.
-
-#### Arguments {#api-send-char-arguments}
-
- - `char ascii_code`
- The character to type.
-
----
-
-### `void send_dword(uint32_t number)` {#api-send-dword}
-
-Type out an eight digit (unsigned 32-bit) hexadecimal value.
-
-The format is `[0-9a-f]{8}`, eg. `00000000` through `ffffffff`.
-
-#### Arguments {#api-send-dword-arguments}
-
- - `uint32_t number`
- The value to type, from 0 to 4,294,967,295.
-
----
-
-### `void send_word(uint16_t number)` {#api-send-word}
-
-Type out a four digit (unsigned 16-bit) hexadecimal value.
-
-The format is `[0-9a-f]{4}`, eg. `0000` through `ffff`.
-
-#### Arguments {#api-send-word-arguments}
-
- - `uint16_t number`
- The value to type, from 0 to 65,535.
-
----
-
-### `void send_byte(uint8_t number)` {#api-send-bytes}
-
-Type out a two digit (8-bit) hexadecimal value.
-
-The format is `[0-9a-f]{2}`, eg. `00` through `ff`.
-
-#### Arguments {#api-send-byte-arguments}
-
- - `uint8_t number`
- The value to type, from 0 to 255.
-
----
-
-### `void send_nibble(uint8_t number)` {#api-send-nibble}
-
-Type out a single hexadecimal digit.
-
-The format is `[0-9a-f]{1}`, eg. `0` through `f`.
-
-#### Arguments {#api-send-nibble-arguments}
-
- - `uint8_t number`
- The value to type, from 0 to 15.
-
----
-
-### `void tap_random_base64(void)` {#api-tap-random-base64}
-
-Type a pseudorandom character from the set `A-Z`, `a-z`, `0-9`, `+` and `/`.
-
----
-
-### `SEND_STRING(string)` {#api-send-string-macro}
-
-Shortcut macro for `send_string_with_delay_P(PSTR(string), 0)`.
-
-On ARM devices, this define evaluates to `send_string_with_delay(string, 0)`.
-
----
-
-### `SEND_STRING_DELAY(string, interval)` {#api-send-string-delay-macro}
-
-Shortcut macro for `send_string_with_delay_P(PSTR(string), interval)`.
-
-On ARM devices, this define evaluates to `send_string_with_delay(string, interval)`.
diff --git a/docs/feature_sequencer.md b/docs/feature_sequencer.md
deleted file mode 100644
index c58b6225ca..0000000000
--- a/docs/feature_sequencer.md
+++ /dev/null
@@ -1,89 +0,0 @@
-# Sequencer
-
-Since QMK has experimental support for MIDI, you can now turn your keyboard into a [step sequencer](https://en.wikipedia.org/wiki/Music_sequencer#Step_sequencers)!
-
-::: warning
-**IMPORTANT:** This feature is highly experimental, it has only been tested on a Planck EZ so far. Also, the scope will be limited to support the drum machine use-case to start with.
-:::
-
-## Enable the step sequencer
-
-Add the following line to your `rules.mk`:
-
-```make
-SEQUENCER_ENABLE = yes
-```
-
-By default the sequencer has 16 steps, but you can override this setting in your `config.h`:
-
-```c
-#define SEQUENCER_STEPS 32
-```
-
-## Tracks
-
-You can program up to 8 independent tracks with the step sequencer. Select the tracks you want to edit, enable or disable some steps, and start the sequence!
-
-## Resolutions
-
-While the tempo defines the absolute speed at which the sequencer goes through the steps, the resolution defines the granularity of these steps (from coarser to finer).
-
-|Resolution |Description |
-|---------- |----------- |
-|`SQ_RES_2` |Every other beat |
-|`SQ_RES_2T` |Every 1.5 beats |
-|`SQ_RES_4` |Every beat |
-|`SQ_RES_4T` |Three times per 2 beats|
-|`SQ_RES_8` |Twice per beat |
-|`SQ_RES_8T` |Three times per beat |
-|`SQ_RES_16` |Four times per beat |
-|`SQ_RES_16T` |Six times per beat |
-|`SQ_RES_32` |Eight times per beat |
-
-## Keycodes
-
-|Key |Aliases |Description |
-|-------------------------------|---------|---------------------------------------------------|
-|`QK_SEQUENCER_ON` |`SQ_ON` |Start the step sequencer |
-|`QK_SEQUENCER_OFF` |`SQ_OFF` |Stop the step sequencer |
-|`QK_SEQUENCER_TOGGLE` |`SQ_TOGG`|Toggle the step sequencer playback |
-|`QK_SEQUENCER_STEPS_ALL` |`SQ_SALL`|Enable all the steps |
-|`QK_SEQUENCER_STEPS_CLEAR` |`SQ_SCLR`|Disable all the steps |
-|`QK_SEQUENCER_TEMPO_DOWN` |`SQ_TMPD`|Decrease the tempo |
-|`QK_SEQUENCER_TEMPO_UP` |`SQ_TMPU`|Increase the tempo |
-|`QK_SEQUENCER_RESOLUTION_DOWN` |`SQ_RESD`|Change to the slower resolution |
-|`QK_SEQUENCER_RESOLUTION_UP` |`SQ_RESU`|Change to the faster resolution |
-|`SQ_S(n)` | |Toggle the step `n` |
-|`SQ_R(n)` | |Set the resolution to n |
-|`SQ_T(n)` | |Set `n` as the only active track or deactivate all |
-
-## Functions
-
-|Function |Description |
-|-------- |----------- |
-|`bool is_sequencer_on(void);` |Return whether the sequencer is playing |
-|`void sequencer_toggle(void);` |Toggle the step sequencer playback |
-|`void sequencer_on(void);` |Start the step sequencer |
-|`void sequencer_off(void);` |Stop the step sequencer |
-|`bool is_sequencer_step_on(uint8_t step);` |Return whether the step is currently enabled |
-|`void sequencer_set_step(uint8_t step, bool value);` |Enable or disable the step |
-|`void sequencer_set_step_on();` |Enable the step |
-|`void sequencer_set_step_off();` |Disable the step |
-|`void sequencer_toggle_step(uint8_t step);` |Toggle the step |
-|`void sequencer_set_all_steps(bool value);` |Enable or disable all the steps |
-|`void sequencer_set_all_steps_on();` |Enable all the steps |
-|`void sequencer_set_all_steps_off();` |Disable all the steps |
-|`uint8_t sequencer_get_tempo(void);` |Return the current tempo |
-|`void sequencer_set_tempo(uint8_t tempo);` |Set the tempo to `tempo` (between 1 and 255) |
-|`void sequencer_increase_tempo(void);` |Increase the tempo |
-|`void sequencer_decrease_tempo(void);` |Decrease the tempo |
-|`sequencer_resolution_t sequencer_get_resolution(void);` |Return the current resolution |
-|`void sequencer_set_resolution(sequencer_resolution_t resolution);` |Set the resolution to `resolution` |
-|`void sequencer_increase_resolution(void);` |Change to the faster resolution |
-|`void sequencer_decrease_resolution(void);` |Change to the slower resolution |
-|`bool is_sequencer_track_active(uint8_t track);` |Return whether the track is active |
-|`void sequencer_set_track_activation(uint8_t track, bool value);` |Activate or deactivate the `track` |
-|`void sequencer_toggle_track_activation(uint8_t track);` |Toggle the `track` |
-|`void sequencer_activate_track(uint8_t track);` |Activate the `track` |
-|`void sequencer_deactivate_track(uint8_t track);` |Deactivate the `track` |
-|`void sequencer_toggle_single_active_track(uint8_t track);` |Set `track` as the only active track or deactivate all |
diff --git a/docs/feature_space_cadet.md b/docs/feature_space_cadet.md
deleted file mode 100644
index cbb79e10ad..0000000000
--- a/docs/feature_space_cadet.md
+++ /dev/null
@@ -1,60 +0,0 @@
-# Space Cadet: The Future, Built In
-
-Steve Losh described the [Space Cadet Shift](https://web.archive.org/web/20230330090938/https://stevelosh.com/blog/2012/10/a-modern-space-cadet/) quite well. Essentially, when you tap Left Shift on its own, you get an opening parenthesis; tap Right Shift on its own and you get the closing one. When held, the Shift keys function as normal. Yes, it's as cool as it sounds, and now even cooler supporting Control and Alt as well!
-
-## Usage
-
-Firstly, in your keymap, do one of the following:
-- Replace the Left Shift key with `SC_LSPO` (Left Shift, Parenthesis Open), and Right Shift with `SC_RSPC` (Right Shift, Parenthesis Close).
-- Replace the Left Control key with `SC_LCPO` (Left Control, Parenthesis Open), and Right Control with `SC_RCPC` (Right Control, Parenthesis Close).
-- Replace the Left Alt key with `SC_LAPO` (Left Alt, Parenthesis Open), and Right Alt with `SC_RAPC` (Right Alt, Parenthesis Close).
-- Replace any Shift key in your keymap with `SC_SENT` (Right Shift, Enter).
-
-## Keycodes
-
-|Keycode |Aliases |Description |
-|----------------------------------------------|---------|----------------------------------------|
-|`QK_SPACE_CADET_LEFT_CTRL_PARENTHESIS_OPEN` |`SC_LCPO`|Left Control when held, `(` when tapped |
-|`QK_SPACE_CADET_RIGHT_CTRL_PARENTHESIS_CLOSE` |`SC_RCPC`|Right Control when held, `)` when tapped|
-|`QK_SPACE_CADET_LEFT_SHIFT_PARENTHESIS_OPEN` |`SC_LSPO`|Left Shift when held, `(` when tapped |
-|`QK_SPACE_CADET_RIGHT_SHIFT_PARENTHESIS_CLOSE`|`SC_RSPC`|Right Shift when held, `)` when tapped |
-|`QK_SPACE_CADET_LEFT_ALT_PARENTHESIS_OPEN` |`SC_LAPO`|Left Alt when held, `(` when tapped |
-|`QK_SPACE_CADET_RIGHT_ALT_PARENTHESIS_CLOSE` |`SC_RAPC`|Right Alt when held, `)` when tapped |
-|`QK_SPACE_CADET_RIGHT_SHIFT_ENTER` |`SC_SENT`|Right Shift when held, Enter when tapped|
-
-## Caveats
-
-Space Cadet's functionality can conflict with the default Command functionality when both Shift keys are held at the same time. See the [Command feature](feature_command) for info on how to change it, or make sure that Command is disabled in your `rules.mk` with:
-
-```make
-COMMAND_ENABLE = no
-```
-
-## Configuration
-
-By default Space Cadet assumes a US ANSI layout, but if your layout uses different keys for parentheses, you can redefine them in your `config.h`. In addition, you can redefine the modifier to send on tap, or even send no modifier at all. The new configuration defines bundle all options up into a single define of 3 key codes in this order: the `Modifier` when held or when used with other keys, the `Tap Modifer` sent when tapped (no modifier if `KC_TRNS`), finally the `Keycode` sent when tapped. Now keep in mind, mods from other keys will still apply to the `Keycode` if say `KC_RSFT` is held while tapping `SC_LSPO` key with `KC_TRNS` as the `Tap Modifer`.
-
-|Define |Default |Description |
-|----------------|-------------------------------|---------------------------------------------------------------------------------|
-|`LSPO_KEYS` |`KC_LSFT, LSPO_MOD, LSPO_KEY` |Send `KC_LSFT` when held, the mod and key defined by `LSPO_MOD` and `LSPO_KEY`. |
-|`RSPC_KEYS` |`KC_RSFT, RSPC_MOD, RSPC_KEY` |Send `KC_RSFT` when held, the mod and key defined by `RSPC_MOD` and `RSPC_KEY`. |
-|`LCPO_KEYS` |`KC_LCTL, KC_LSFT, KC_9` |Send `KC_LCTL` when held, the mod `KC_LSFT` with the key `KC_9` when tapped. |
-|`RCPC_KEYS` |`KC_RCTL, KC_RSFT, KC_0` |Send `KC_RCTL` when held, the mod `KC_RSFT` with the key `KC_0` when tapped. |
-|`LAPO_KEYS` |`KC_LALT, KC_LSFT, KC_9` |Send `KC_LALT` when held, the mod `KC_LSFT` with the key `KC_9` when tapped. |
-|`RAPC_KEYS` |`KC_RALT, KC_RSFT, KC_0` |Send `KC_RALT` when held, the mod `KC_RSFT` with the key `KC_0` when tapped. |
-|`SFTENT_KEYS` |`KC_RSFT, KC_TRNS, SFTENT_KEY` |Send `KC_RSFT` when held, no mod with the key `SFTENT_KEY` when tapped. |
-|`SPACE_CADET_MODIFIER_CARRYOVER` |*Not defined* |Store current modifiers before the hold mod is pressed and use them with the tap mod and keycode. Useful for when you frequently release a modifier before triggering Space Cadet. |
-
-
-## Obsolete Configuration
-
-These defines are used in the above defines internally to support backwards compatibility, so you may continue to use them, however the above defines open up a larger range of flexibility than before. As an example, say you want to not send any modifier when you tap just `SC_LSPO`, with the old defines you had an all or nothing choice of using the `DISABLE_SPACE_CADET_MODIFIER` define. Now you can define that key as: `#define LSPO_KEYS KC_LSFT, KC_TRNS, KC_9`. This tells the system to set Left Shift if held or used with other keys, then on tap send no modifier (transparent) with the `KC_9`.
-
-|Define |Default |Description |
-|------------------------------|-------------|------------------------------------------------------------------|
-|`LSPO_KEY` |`KC_9` |The keycode to send when Left Shift is tapped |
-|`RSPC_KEY` |`KC_0` |The keycode to send when Right Shift is tapped |
-|`LSPO_MOD` |`KC_LSFT` |The modifier to apply to `LSPO_KEY` |
-|`RSPC_MOD` |`KC_RSFT` |The modifier to apply to `RSPC_KEY` |
-|`SFTENT_KEY` |`KC_ENT` |The keycode to send when the Shift key is tapped |
-|`DISABLE_SPACE_CADET_MODIFIER`|*Not defined*|If defined, prevent the Space Cadet from applying a modifier |
diff --git a/docs/feature_split_keyboard.md b/docs/feature_split_keyboard.md
deleted file mode 100644
index c39d0a7e08..0000000000
--- a/docs/feature_split_keyboard.md
+++ /dev/null
@@ -1,508 +0,0 @@
-# Split Keyboard
-
-Many keyboards in the QMK Firmware repo are "split" keyboards. They use two controllers—one plugging into USB, and the second connected by a serial or an I2C connection over a TRRS or similar cable.
-
-Split keyboards can have a lot of benefits, but there is some additional work needed to get them enabled.
-
-QMK Firmware has a generic implementation that is usable by any board, as well as numerous board specific implementations.
-
-For this, we will mostly be talking about the generic implementation used by the Let's Split and other keyboards.
-
-::: warning
-ARM split supports most QMK subsystems when using the 'serial' and 'serial_usart' drivers. I2C slave is currently unsupported.
-:::
-
-::: warning
-Both sides must use the same MCU family, for eg two Pro Micro-compatible controllers or two Blackpills. Currently, mixing AVR and ARM is not possible as ARM vs AVR uses different method for serial communication, and are not compatible. Moreover Blackpill's uses 3.3v logic, and atmega32u4 uses 5v logic.
-:::
-
-## Compatibility Overview
-
-| Transport | AVR | ARM |
-|------------------------------|--------------------|--------------------|
-| ['serial'](serial_driver) | :heavy_check_mark: | :white_check_mark: 1 |
-| I2C | :heavy_check_mark: | |
-
-Notes:
-
-1. Both hardware and software limitations are detailed within the [driver documentation](serial_driver).
-
-## Hardware Configuration
-
-This assumes that you're using two Pro Micro-compatible controllers, and are using TRRS jacks to connect to two halves.
-
-### Required Hardware
-
-Apart from diodes and key switches for the keyboard matrix in each half, you will need 2x TRRS sockets and 1x TRRS cable.
-
-Alternatively, you can use any sort of cable and socket that has at least 3 wires.
-
-If you want to use I2C to communicate between halves, you will need a cable with at least 4 wires and 2x 4.7kΩ pull-up resistors.
-
-#### Considerations
-
-The most commonly used connection is a TRRS cable and jacks. These provide 4 wires, making them very useful for split keyboards, and are easy to find.
-
-However, since one of the wires carries VCC, this means that the boards are not hot pluggable. You should always disconnect the board from USB before unplugging and plugging in TRRS cables, or you can short the controller, or worse.
-
-Another option is to use phone cables (as in, old school RJ-11/RJ-14 cables). Make sure that you use one that actually supports 4 wires/lanes.
-
-However, USB cables, SATA cables, and even just 4 wires have been known to be used for communication between the controllers.
-
-::: warning
-Using USB cables for communication between the controllers works just fine, but the connector could be mistaken for a normal USB connection and potentially short out the keyboard, depending on how it's wired. For this reason, they are not recommended for connecting split keyboards.
-:::
-
-### Serial Wiring
-
-The 3 wires of the TRS/TRRS cable need to connect GND, VCC, and D0/D1/D2/D3 (aka PD0/PD1/PD2/PD3) between the two Pro Micros.
-
-::: tip
-Note that the pin used here is actually set by `SOFT_SERIAL_PIN` below.
-:::
-
-
-
-
-### I2C Wiring
-
-The 4 wires of the TRRS cable need to connect GND, VCC, and SCL and SDA (aka PD0/pin 3 and PD1/pin 2, respectively) between the two Pro Micros.
-
-The pull-up resistors may be placed on either half. If you wish to use the halves independently, it is also possible to use 4 resistors and have the pull-ups in both halves.
-Note that the total resistance for the connected system should be within spec at 2.2k-10kOhm, with an 'ideal' at 4.7kOhm, regardless of the placement and number.
-
-
-
-## Firmware Configuration
-
-To enable the split keyboard feature, add the following to your `rules.mk`:
-
-```make
-SPLIT_KEYBOARD = yes
-```
-
-If you're using a custom transport (communication method), then you will also need to add:
-
-```make
-SPLIT_TRANSPORT = custom
-```
-
-### Layout Macro
-
-Configuring your layout in a split keyboard works slightly differently to a non-split keyboard. Take for example the following layout. The top left numbers refer to the matrix row and column, and the bottom right are the order of the keys in the layout:
-
-
-
-Since the matrix scanning procedure operates on entire rows, it first populates the left half's rows, then the right half's. Thus, the matrix as QMK views it has double the rows instead of double the columns:
-
-
-
-### Setting Handedness
-
-By default, the firmware does not know which side is which; it needs some help to determine that. There are several ways to do this, listed in order of precedence.
-
-#### Handedness by Pin
-
-You can configure the firmware to read a pin on the controller to determine handedness. To do this, add the following to your `config.h` file:
-
-```c
-#define SPLIT_HAND_PIN B7
-```
-
-This will read the specified pin. By default, if it's high, then the controller assumes it is the left hand, and if it's low, it's assumed to be the right side.
-
-This behaviour can be flipped by adding this to you `config.h` file:
-
-```c
-#define SPLIT_HAND_PIN_LOW_IS_LEFT
-```
-
-#### Handedness by Matrix Pin
-
-You can configure the firmware to read key matrix pins on the controller to determine handedness. To do this, add the following to your `config.h` file:
-
-```c
-#define SPLIT_HAND_MATRIX_GRID D0, F1
-```
-
-The first pin is the output pin and the second is the input pin.
-
-Some keyboards have unused intersections in the key matrix. This setting uses one of these unused intersections to determine the handedness.
-
-Normally, when a diode is connected to an intersection, it is judged to be right. If you add the following definition, it will be judged to be left.
-
-```c
-#define SPLIT_HAND_MATRIX_GRID_LOW_IS_LEFT
-```
-
-Note that adding a diode at a previously unused intersection will effectively tell the firmware that there is a key held down at that point. You can instruct qmk to ignore that intersection by defining `MATRIX_MASKED` and then defining a `matrix_row_t matrix_mask[MATRIX_ROWS]` array in your keyboard config. Each bit of a single value (starting form the least-significant bit) is used to tell qmk whether or not to pay attention to key presses at that intersection.
-
-While `MATRIX_MASKED` isn't necessary to use `SPLIT_HAND_MATRIX_GRID` successfully, without it you may experience issues trying to suspend your computer with your keyboard attached as the matrix will always report at least one key-press.
-
-#### Handedness by EEPROM
-
-This method sets the keyboard's handedness by setting a flag in the persistent storage (`EEPROM`). This is checked when the controller first starts up, and determines what half the keyboard is, and how to orient the keyboard layout.
-
-
-To enable this method, add the following to your `config.h` file:
-
-```c
-#define EE_HANDS
-```
-
-Next, you will have to flash the correct handedness option to the controller on each halve. You can do this manually with the following bootloader targets using `qmk flash -kb 
+
+Changing the **Hue** cycles around the circle.