gitbot/qmk_firmware
0
0
Fork 0
mirror of https://github.com/qmk/qmk_firmware.git synced 2024-11-25 04:43:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

[docs] Organize driver & feature docs into subfolders (#23848)

Browse Source 
Co-authored-by: Nick Brassel <nick@tzarc.org>
This commit is contained in:
Ryan 2024-06-02 12:42:24 +10:00 committed by GitHub
parent fa6d23235b
commit 78a0adfbb4
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
97 changed files with 282 additions and 285 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
docs/ChangeLog/20210828.md
View File

@ -10,11 +10,11 @@ It is also now possible to define combos that have keys overlapping with other c
### Key Overrides ([#11422](https://github.com/qmk/qmk_firmware/pull/11422)) {#key-overrides}
QMK now has a new feature: [key overrides](../feature_key_overrides). This feature allows for overriding the output of key combinations involving modifiers. As an example, pressing <kbd>Shift+2</kbd> normally results in an <kbd>@</kbd> on US-ANSI keyboard layouts -- the new key overrides allow for adding similar functionality, but for any <kbd>modifier + key</kbd> press.
QMK now has a new feature: [key overrides](../features/key_overrides). This feature allows for overriding the output of key combinations involving modifiers. As an example, pressing <kbd>Shift+2</kbd> normally results in an <kbd>@</kbd> on US-ANSI keyboard layouts -- the new key overrides allow for adding similar functionality, but for any <kbd>modifier + key</kbd> press.
To illustrate, it's now possible to use the key overrides feature to translate <kbd>Shift + Backspace</kbd> into <kbd>Delete</kbd> -- an often-requested example of where this functionality comes in handy.
There's far more to describe that what lives in this changelog, so head over to the [key overrides documentation](../feature_key_overrides) for more examples and info.
There's far more to describe that what lives in this changelog, so head over to the [key overrides documentation](../features/key_overrides) for more examples and info.
### Digitizer support ([#12851](https://github.com/qmk/qmk_firmware/pull/12851))

4
docs/ChangeLog/20211127.md
View File

@ -31,7 +31,7 @@ QMK now has core-supplied support for the following pointing device peripherals:
| `POINTING_DEVICE_DRIVER = pimoroni_trackball` | Pimoroni Trackball |
| `POINTING_DEVICE_DRIVER = pmw3360` | PMW 3360 |
See the new documentation for the [Pointing Device](../feature_pointing_device) feature for more information on specific configuration for each driver.
See the new documentation for the [Pointing Device](../features/pointing_device) feature for more information on specific configuration for each driver.
### Dynamic Tapping Term ([#11036](https://github.com/qmk/qmk_firmware/pull/11036)) {#dynamic-tapping-term}
@ -116,7 +116,7 @@ Related to the previous section -- RGB Matrix modes have now been made to be opt
Most keyboards keep their original functionality, but over time the QMK maintainers have found that removal of animations ends up being the quickest way to free up space... and some keyboards have had animations such as reactive effects disabled by default in order to still fit within the flash space available.
The full list of configurables to turn specific animations back on can be found at on the [RGB Matrix documentation](../feature_rgb_matrix#rgb-matrix-effects) page.
The full list of configurables to turn specific animations back on can be found at on the [RGB Matrix documentation](../features/rgb_matrix#rgb-matrix-effects) page.
### OLED task refactoring ([#14864](https://github.com/qmk/qmk_firmware/pull/14864)) {#oled-task-refactor}

2
docs/ChangeLog/20220226.md
View File

@ -12,7 +12,7 @@ Something something *Lets go gamers!*
Pointing devices can now be shared across a split keyboard with support for a single pointing device or a pointing device on each side.
See the [Pointing Device](../feature_pointing_device) documentation for further configuration options.
See the [Pointing Device](../features/pointing_device) documentation for further configuration options.
## Changes Requiring User Action {#changes-requiring-user-action}

4
docs/ChangeLog/20220528.md
View File

@ -8,7 +8,7 @@ This is a new feature that allows for capslock-like functionality that turns its
For instance, if you wish to type "QMK" without holding shift the entire time, you can either tap both left and right shift, or double-tap shift, to turn on _Caps Word_ -- then type `qmk` (lowercase) without holding shift. Once you hit any key other than `a`--`z`, `0`--`9`, `-`, `_`, delete, or backspace, this will go back to normal typing!
There are other activation mechanisms as well as configurable options like timeout and the like -- see the [Caps Word documentation](../feature_caps_word) for more information.
There are other activation mechanisms as well as configurable options like timeout and the like -- see the [Caps Word documentation](../features/caps_word) for more information.
### Quantum Painter ([#10174](https://github.com/qmk/qmk_firmware/pull/10174)) {#quantum-painter}
@ -26,7 +26,7 @@ Quantum Painter is not supported on AVR due to complexity and size constraints.
### Encoder Mapping ([#13286](https://github.com/qmk/qmk_firmware/pull/13286)) {#encoder-mapping}
One of the long-standing complaints with Encoders is that there has been no easy way to configure them in user keymaps. [#13286](https://github.com/qmk/qmk_firmware/pull/13286) added support for [Encoder Mapping](../feature_encoders#encoder-map), which allows users to define encoder functionality in a similar way to their normal keymap.
One of the long-standing complaints with Encoders is that there has been no easy way to configure them in user keymaps. [#13286](https://github.com/qmk/qmk_firmware/pull/13286) added support for [Encoder Mapping](../features/encoders#encoder-map), which allows users to define encoder functionality in a similar way to their normal keymap.
::: warning
This is not yet supported by QMK Configurator. It is also unlikely to ever be supported by VIA.

2
docs/ChangeLog/20220827.md
View File

@ -83,7 +83,7 @@ The now-EOL kbfirmware allowed people who aren't set up with QMK the ability to
QMK has had the ability to write to internal MCU flash in order to emulate EEPROM for some time now, but it was only limited to a small number of MCUs. The base HAL used by QMK for a large number of ARM devices provides a "proper" embedded MCU flash driver, so _@tzarc_ decoupled the wear-leveling algorithm from the old flash writing code, improved it, wrote some tests, and enabled its use for a much larger number of other devices... including RP2040's XIP flash, and external SPI NOR Flash.
See the [EEPROM Driver](../eeprom_driver) documentation for more information.
See the [EEPROM Driver](../drivers/eeprom) documentation for more information.
### Pointing Device Improvements ([#16371](https://github.com/qmk/qmk_firmware/pull/16371), [#17111](https://github.com/qmk/qmk_firmware/pull/17111), [#17176](https://github.com/qmk/qmk_firmware/pull/17176), [#17482](https://github.com/qmk/qmk_firmware/pull/17482), [#17776](https://github.com/qmk/qmk_firmware/pull/17776), [#17613](https://github.com/qmk/qmk_firmware/pull/17613)) {#pointing-device-improvements}

4
docs/ChangeLog/20221126.md
View File

@ -4,7 +4,7 @@
### Autocorrect ([#15699](https://github.com/qmk/qmk_firmware/pull/15699)) {#autocorrect}
_@getreuer_ in their infinite wisdom decided that autocorrect was a feature needed by QMK. As is customary, _@drashna_ adapted it to core and got it into a state that everyone else can use it. See [Feature: Autocorrect](../feature_autocorrect) for more ifnormation (grin).
_@getreuer_ in their infinite wisdom decided that autocorrect was a feature needed by QMK. As is customary, _@drashna_ adapted it to core and got it into a state that everyone else can use it. See [Feature: Autocorrect](../features/autocorrect) for more ifnormation (grin).
## Changes Requiring User Action {#changes-requiring-user-action}
@ -132,7 +132,7 @@ The equivalent transformations should be done for LED Matrix boards.
### Unicode mode refactoring {#unicode-mode-renaming}
Unicode modes were renamed in order to prevent collision with equivalent keycodes. The available values for `UNICODE_SELECTED_MODES` changed -- see [Feature: Unicode](../feature_unicode#setting-the-input-mode) for the new list of values and how to configure them.
Unicode modes were renamed in order to prevent collision with equivalent keycodes. The available values for `UNICODE_SELECTED_MODES` changed -- see [Feature: Unicode](../features/unicode#setting-the-input-mode) for the new list of values and how to configure them.
## Notable core changes {#notable-core}

2
docs/ChangeLog/20230226.md
View File

@ -106,7 +106,7 @@ void leader_end_user(void) {
}
```
For more information please see the [Leader Key documentation](../feature_leader_key).
For more information please see the [Leader Key documentation](../features/leader_key).
### Updated Keyboard Codebases {#updated-keyboard-codebases}

4
docs/ChangeLog/20230528.md
View File

@ -24,7 +24,7 @@ Of note for keyboard designers:
A new pair of keys has been added to QMK -- namely `QK_REPEAT_KEY` and `QK_ALT_REPEAT_KEY` (shortened: `QK_REP`/`QK_AREP`). These allow you to repeat the last key pressed, or in the case of the alternate key, press the "opposite" of the last key. For example, if you press `KC_LEFT`, pressing `QK_REPEAT_KEY` afterwards repeats `KC_LEFT`, but pressing `QK_ALT_REPEAT_KEY` instead sends `KC_RIGHT`.
The full list of default alternate keys is available on the [Repeat Key](../feature_repeat_key) documentation.
The full list of default alternate keys is available on the [Repeat Key](../features/repeat_key) documentation.
To enable these keys, in your keymap's `rules.mk`, add:
@ -93,7 +93,7 @@ Additionally, this ensures that builds on QMK Configurator produce some sort of
The "classic" OLED driver picked up support for additional sizes of OLED displays, support for the SH1107 controller, and SPI-based OLED support.
Other configurable items are available and can be found on the [OLED Driver page](../feature_oled_driver).
Other configurable items are available and can be found on the [OLED Driver page](../features/oled_driver).
## Full changelist {#full-changelist}

2
docs/ChangeLog/20230827.md
View File

@ -42,7 +42,7 @@ AVR sees minimal (if any) benefit -- `double` was interpreted as `float` on AVR
### Remove encoder in-matrix workaround code ([#20389](https://github.com/qmk/qmk_firmware/pull/20389)) {#remove-encoder-in-matrix-workaround-code}
Some keyboards "hacked" encoder support into spare slots in the key matrix in order to interoperate with VIA. This workaround is no longer necessary, and the code has been removed. If you have a keyboard that uses this workaround, you will need to update your keymap to use the new [Encoder Map](../feature_encoders#encoder-map) API instead.
Some keyboards "hacked" encoder support into spare slots in the key matrix in order to interoperate with VIA. This workaround is no longer necessary, and the code has been removed. If you have a keyboard that uses this workaround, you will need to update your keymap to use the new [Encoder Map](../features/encoders#encoder-map) API instead.
### Unicodemap keycodes rename ([#21092](https://github.com/qmk/qmk_firmware/pull/21092)) {#unicodemap-keycodes-rename}

2
docs/ChangeLog/20240225.md
View File

@ -120,7 +120,7 @@ In some cases, accidental automatic activation of the mouse layer made it diffic
### DIP Switch Mapping ([#22543](https://github.com/qmk/qmk_firmware/pull/22543)) {#dip-switch-map}
Much like Encoder Mapping, DIP Switch Mapping allows for specifying a table of actions to execute when a DIP switch state changes. See the [DIP Switch Documentation](../feature_dip_switch#dip-switch-map) for more information.
Much like Encoder Mapping, DIP Switch Mapping allows for specifying a table of actions to execute when a DIP switch state changes. See the [DIP Switch Documentation](../features/dip_switch#dip-switch-map) for more information.
```c
#if defined(DIP_SWITCH_MAP_ENABLE)

112
docs/_sidebar.json
View File

@ -103,45 +103,45 @@
{
"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": "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 +157,35 @@
{ "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": "Bluetooth", "link": "/features/bluetooth" },
{ "text": "Bootmagic Lite", "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" }
]
},
{
@ -226,19 +226,19 @@
"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": "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" }
]
},

2
docs/cli_commands.md
View File

@ -749,7 +749,7 @@ options:
## `qmk generate-rgb-breathe-table`
This command generates a lookup table (LUT) header file for the [RGB Lighting](feature_rgblight) feature's breathing animation. Place this file in your keyboard or keymap directory as `rgblight_breathe_table.h` to override the default LUT in `quantum/rgblight/`.
This command generates a lookup table (LUT) header file for the [RGB Lighting](features/rgblight) feature's breathing animation. Place this file in your keyboard or keymap directory as `rgblight_breathe_table.h` to override the default LUT in `quantum/rgblight/`.
**Usage**:

12
docs/config_options.md
View File

@ -207,7 +207,7 @@ If you define these options you will enable the associated feature, which may in
* `#define TAP_HOLD_CAPS_DELAY 80`
* Sets the delay for Tap Hold keys (`LT`, `MT`) when using `KC_CAPS_LOCK` keycode, as this has some special handling on MacOS. The value is in milliseconds, and defaults to 80 ms if not defined. For macOS, you may want to set this to 200 or higher.
* `#define KEY_OVERRIDE_REPEAT_DELAY 500`
* Sets the key repeat interval for [key overrides](feature_key_overrides).
* Sets the key repeat interval for [key overrides](features/key_overrides).
* `#define LEGACY_MAGIC_HANDLING`
* Enables magic configuration handling for advanced keycodes (such as Mod Tap and Layer Tap)
@ -217,14 +217,14 @@ If you define these options you will enable the associated feature, which may in
* `#define WS2812_DI_PIN D7`
* pin the DI on the WS2812 is hooked-up to
* `#define RGBLIGHT_LAYERS`
* Lets you define [lighting layers](feature_rgblight#lighting-layers) that can be toggled on or off. Great for showing the current keyboard layer or caps lock state.
* Lets you define [lighting layers](features/rgblight#lighting-layers) that can be toggled on or off. Great for showing the current keyboard layer or caps lock state.
* `#define RGBLIGHT_MAX_LAYERS`
* Defaults to 8. Can be expanded up to 32 if more [lighting layers](feature_rgblight#lighting-layers) are needed.
* Defaults to 8. Can be expanded up to 32 if more [lighting layers](features/rgblight#lighting-layers) are needed.
* Note: Increasing the maximum will increase the firmware size and slow sync on split keyboards.
* `#define RGBLIGHT_LAYER_BLINK`
* Adds ability to [blink](feature_rgblight#lighting-layer-blink) a lighting layer for a specified number of milliseconds (e.g. to acknowledge an action).
* Adds ability to [blink](features/rgblight#lighting-layer-blink) a lighting layer for a specified number of milliseconds (e.g. to acknowledge an action).
* `#define RGBLIGHT_LAYERS_OVERRIDE_RGB_OFF`
* If defined, then [lighting layers](feature_rgblight#overriding-rgb-lighting-onoff-status) will be shown even if RGB Light is off.
* If defined, then [lighting layers](features/rgblight#overriding-rgb-lighting-onoff-status) will be shown even if RGB Light is off.
* `#define RGBLIGHT_LED_COUNT 12`
* number of LEDs
* `#define RGBLIGHT_SPLIT`
@ -358,7 +358,7 @@ There are a few different ways to set handedness for split keyboards (listed in
* `#define SPLIT_TRANSACTION_IDS_KB .....`
* `#define SPLIT_TRANSACTION_IDS_USER .....`
* Allows for custom data sync with the slave when using the QMK-provided split transport. See [custom data sync between sides](feature_split_keyboard#custom-data-sync) for more information.
* Allows for custom data sync with the slave when using the QMK-provided split transport. See [custom data sync between sides](features/split_keyboard#custom-data-sync) for more information.
# The `rules.mk` File

2
docs/custom_quantum_functions.md
View File

@ -206,7 +206,7 @@ Similar to `matrix_scan_*`, these are called as often as the MCU can handle. To
### Example `void housekeeping_task_user(void)` implementation
This example will show you how to use `void housekeeping_task_user(void)` to turn off [RGB Light](feature_rgblight). For RGB Matrix, the [builtin](feature_rgb_matrix#additional-configh-options) `RGB_MATRIX_TIMEOUT` should be used.
This example will show you how to use `void housekeeping_task_user(void)` to turn off [RGB Light](features/rgblight). For RGB Matrix, the [builtin](features/rgb_matrix#additional-configh-options) `RGB_MATRIX_TIMEOUT` should be used.
First, add the following lines to your keymap's `config.h`:

2
docs/documentation_best_practices.md
View File

@ -69,4 +69,4 @@ This page describes my cool feature. You can use my cool feature to make coffee
|KC_SUGAR||Order Sugar|
```
Place your documentation into `docs/feature_<my_cool_feature>.md`, and add that file to the appropriate place in `docs/_sidebar.json`. If you have added any keycodes be sure to add them to `docs/keycodes.md` with a link back to your feature page.
Place your documentation into `docs/features/<my_cool_feature>.md`, and add that file to the appropriate place in `docs/_sidebar.json`. If you have added any keycodes be sure to add them to `docs/keycodes.md` with a link back to your feature page.

4
docs/driver_installation_zadig.md
View File

@ -8,8 +8,8 @@ We recommend the use of the [Zadig](https://zadig.akeo.ie/) utility. If you have
## Installation
Put your keyboard into bootloader mode, either by hitting the `QK_BOOT` keycode (which may be on a different layer), or by pressing the reset switch that's usually located on the underside of the board. If your keyboard has neither, try holding Escape or Space+`B` as you plug it in (see the [Bootmagic Lite](feature_bootmagic) docs for more details). Some boards use [Command](feature_command) instead of Bootmagic; in this case, you can enter bootloader mode by hitting Left Shift+Right Shift+`B` or Left Shift+Right Shift+Escape at any point while the keyboard is plugged in.
Some keyboards may have specific instructions for entering the bootloader. For example, the [Bootmagic Lite](feature_bootmagic) key (default: Escape) might be on a different key, e.g. Left Control; or the magic combination for Command (default: Left Shift+Right Shift) might require you to hold something else, e.g. Left Control+Right Control. Refer to the board's README file if you are unsure.
Put your keyboard into bootloader mode, either by hitting the `QK_BOOT` keycode (which may be on a different layer), or by pressing the reset switch that's usually located on the underside of the board. If your keyboard has neither, try holding Escape or Space+`B` as you plug it in (see the [Bootmagic Lite](features/bootmagic) docs for more details). Some boards use [Command](features/command) instead of Bootmagic; in this case, you can enter bootloader mode by hitting Left Shift+Right Shift+`B` or Left Shift+Right Shift+Escape at any point while the keyboard is plugged in.
Some keyboards may have specific instructions for entering the bootloader. For example, the [Bootmagic Lite](features/bootmagic) key (default: Escape) might be on a different key, e.g. Left Control; or the magic combination for Command (default: Left Shift+Right Shift) might require you to hold something else, e.g. Left Control+Right Control. Refer to the board's README file if you are unsure.
To put a device in bootloader mode with USBaspLoader, tap the `RESET` button while holding down the `BOOT` button.
Alternatively, hold `BOOT` while inserting the USB cable.

2
docs/adc_driver.md → docs/drivers/adc.md
View File

@ -1,6 +1,6 @@
# 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).
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](../features/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.

4
docs/apa102_driver.md → docs/drivers/apa102.md
View File

@ -1,10 +1,10 @@
# 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.
This driver provides support for APA102 addressable RGB LEDs. They are similar to the [WS2812](ws2812) 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.
In most cases, the APA102 driver code is automatically included if you are using either the [RGBLight](../features/rgblight) or [RGB Matrix](../features/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`:

2
docs/audio_driver.md → docs/drivers/audio.md
View File

@ -1,6 +1,6 @@
# 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.
The [Audio feature](../features/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.

2
docs/eeprom_driver.md → docs/drivers/eeprom.md
View File

@ -133,7 +133,7 @@ If your MCU does not boot after swapping to the EFL wear-leveling driver, it's l
## Wear-leveling SPI Flash Driver Configuration {#wear_leveling-flash_spi-driver-configuration}
This driver performs writes to an external SPI NOR Flash peripheral. It also requires a working configuration for the SPI NOR Flash peripheral -- see the [flash driver](flash_driver) documentation for more information.
This driver performs writes to an external SPI NOR Flash peripheral. It also requires a working configuration for the SPI NOR Flash peripheral -- see the [flash driver](flash) documentation for more information.
Configurable options in your keyboard's `config.h`:

0
docs/flash_driver.md → docs/drivers/flash.md
View File

0
docs/gpio_control.md → docs/drivers/gpio.md
View File

2
docs/i2c_driver.md → docs/drivers/i2c.md
View File

@ -4,7 +4,7 @@ The I2C Master drivers used in QMK have a set of common functions to allow porta
## Usage {#usage}
In most cases, the I2C Master driver code is automatically included if you are using a feature or driver which requires it, such as [OLED](feature_oled_driver).
In most cases, the I2C Master driver code is automatically included if you are using a feature or driver which requires it, such as [OLED](../features/oled_driver).
However, if you need to use the driver standalone, add the following to your `rules.mk`:

4
docs/serial_driver.md → docs/drivers/serial.md
View File

@ -1,6 +1,6 @@
# 'serial' Driver
The Serial driver powers the [Split Keyboard](feature_split_keyboard) feature. Several implementations are available that cater to the platform and capabilites of MCU in use. Note that none of the drivers support split keyboards with more than two halves.
The Serial driver powers the [Split Keyboard](../features/split_keyboard) feature. Several implementations are available that cater to the platform and capabilites of MCU in use. Note that none of the drivers support split keyboards with more than two halves.
| Driver | AVR | ARM | Connection between halves |
| --------------------------------------- | ------------------ | ------------------ | --------------------------------------------------------------------------------------------- |
@ -298,7 +298,7 @@ If you're having issues withe serial communication, you can enable debug message
```
::: tip
The messages will be printed out to the `CONSOLE` output. For additional information, refer to [Debugging/Troubleshooting QMK](faq_debug).
The messages will be printed out to the `CONSOLE` output. For additional information, refer to [Debugging/Troubleshooting QMK](../faq_debug).
:::
## Alternate Functions for selected STM32 MCUs

2
docs/spi_driver.md → docs/drivers/spi.md
View File

@ -4,7 +4,7 @@ The SPI Master drivers used in QMK have a set of common functions to allow porta
## Usage {#usage}
In most cases, the SPI Master driver code is automatically included if you are using a feature or driver which requires it, such as [OLED](feature_oled_driver).
In most cases, the SPI Master driver code is automatically included if you are using a feature or driver which requires it, such as [OLED](../features/oled_driver).
However, if you need to use the driver standalone, add the following to your `rules.mk`:

0
docs/uart_driver.md → docs/drivers/uart.md
View File

2
docs/ws2812_driver.md → docs/drivers/ws2812.md
View File

@ -10,7 +10,7 @@ The LEDs can be chained together, and the remaining data is passed on to the nex
## Usage {#usage}
In most cases, the WS2812 driver code is automatically included if you are using either the [RGBLight](feature_rgblight) or [RGB Matrix](feature_rgb_matrix) feature with the `ws2812` driver set, and you would use those APIs instead.
In most cases, the WS2812 driver code is automatically included if you are using either the [RGBLight](../features/rgblight) or [RGB Matrix](../features/rgb_matrix) feature with the `ws2812` 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`:

2
docs/easy_maker.md
View File

@ -5,7 +5,7 @@ Have you ever needed an easy way to program a controller, such as a Proton C or
There are different styles of Easy Maker available depending on your needs:
* [Direct Pin](https://config.qmk.fm/#/?filter=ez_maker/direct) - Connect a single switch to a single pin
* Direct Pin + Backlight (Coming Soon) - Like Direct Pin but dedicates a single pin to [Backlight](feature_backlight) control
* Direct Pin + Backlight (Coming Soon) - Like Direct Pin but dedicates a single pin to [Backlight](features/backlight) control
* Direct Pin + Numlock (Coming Soon) - Like Direct Pin but dedicates a single pin to the Numlock LED
* Direct Pin + Capslock (Coming Soon) - Like Direct Pin but dedicates a single pin to the Capslock LED
* Direct Pin + Encoder (Coming Soon) - Like Direct Pin but uses 2 pins to add a single rotary encoder

2
docs/faq_build.md
View File

@ -66,4 +66,4 @@ Due to how EEPROM works on ARM based chips, saved settings may no longer be vali
[Planck rev6 reset EEPROM](https://cdn.discordapp.com/attachments/473506116718952450/539284620861243409/planck_rev6_default.bin) can be used to force an eeprom reset. After flashing this image, flash your normal firmware again which should restore your keyboard to _normal_ working order.
[Preonic rev3 reset EEPROM](https://cdn.discordapp.com/attachments/473506116718952450/537849497313738762/preonic_rev3_default.bin)
If bootmagic is enabled in any form, you should be able to do this too (see [Bootmagic docs](feature_bootmagic) and keyboard info for specifics on how to do this).
If bootmagic is enabled in any form, you should be able to do this too (see [Bootmagic docs](features/bootmagic) and keyboard info for specifics on how to do this).

2
docs/faq_debug.md
View File

@ -4,7 +4,7 @@ This page details various common questions people have about troubleshooting the
## Debugging {#debugging}
Your keyboard will output debug information if you have `CONSOLE_ENABLE = yes` in your `rules.mk`. By default the output is very limited, but you can turn on debug mode to increase the amount of debug output. Use the `DB_TOGG` keycode in your keymap, use the [Command](feature_command) feature to enable debug mode, or add the following code to your keymap.
Your keyboard will output debug information if you have `CONSOLE_ENABLE = yes` in your `rules.mk`. By default the output is very limited, but you can turn on debug mode to increase the amount of debug output. Use the `DB_TOGG` keycode in your keymap, use the [Command](features/command) feature to enable debug mode, or add the following code to your keymap.
```c
void keyboard_post_init_user(void) {

6
docs/faq_keymap.md
View File

@ -45,7 +45,7 @@ QMK has a couple of features which allow you to change the behavior of your keyb
Refer to the EEPROM clearing methods above, which should return those keys to normal operation. If that doesn't work, look here:
* [Magic Keycodes](keycodes_magic)
* [Command](feature_command)
* [Command](features/command)
## The Menu Key Isn't Working
@ -86,7 +86,7 @@ Old vintage mechanical keyboards occasionally have lock switches but modern ones
## Input Special Characters Other Than ASCII like Cédille 'Ç'
See the [Unicode](feature_unicode) feature.
See the [Unicode](features/unicode) feature.
## `Fn` Key on macOS
@ -130,7 +130,7 @@ https://github.com/tekezo/Karabiner/issues/403
## Esc and <code>&#96;</code> on a Single Key
See the [Grave Escape](feature_grave_esc) feature.
See the [Grave Escape](features/grave_esc) feature.
## Eject on Mac OSX

4
docs/feature_advanced_keycodes.md
View File

@ -160,7 +160,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 +184,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)

16
docs/feature_converters.md
View File

@ -39,7 +39,7 @@ qmk flash -c -kb keebio/bdn9/rev1 -km default -e CONVERT_TO=proton_c
You can also add the same `CONVERT_TO=<target>` to your keymap's `rules.mk`, which will accomplish the same thing.
::: tip
If you get errors about `PORTB/DDRB`, etc not being defined, you'll need to convert the keyboard's code to use the [GPIO Controls](gpio_control) that will work for both ARM and AVR. This shouldn't affect the AVR builds at all.
If you get errors about `PORTB/DDRB`, etc not being defined, you'll need to convert the keyboard's code to use the [GPIO Controls](drivers/gpio) that will work for both ARM and AVR. This shouldn't affect the AVR builds at all.
:::
### Conditional Configuration
@ -118,11 +118,11 @@ The following defaults are based on what has been implemented for STM32 boards.
| Feature | Notes |
|----------------------------------------------|------------------------------------------------------------------------------------------------------------------|
| [Audio](feature_audio) | Enabled |
| [RGB Lighting](feature_rgblight) | Disabled |
| [Backlight](feature_backlight) | Forces [task driven PWM](feature_backlight#software-pwm-driver) until ARM can provide automatic configuration |
| [Audio](features/audio) | Enabled |
| [RGB Lighting](features/rgblight) | Disabled |
| [Backlight](features/backlight) | Forces [task driven PWM](features/backlight#software-pwm-driver) until ARM can provide automatic configuration |
| USB Host (e.g. USB-USB converter) | Not supported (USB host code is AVR specific and is not currently supported on ARM) |
| [Split keyboards](feature_split_keyboard) | Partial - heavily dependent on enabled features |
| [Split keyboards](features/split_keyboard) | Partial - heavily dependent on enabled features |
### Adafruit KB2040 {#kb2040}
@ -130,10 +130,10 @@ The following defaults are based on what has been implemented for [RP2040](platf
| Feature | Notes |
|----------------------------------------------|------------------------------------------------------------------------------------------------------------------|
| [RGB Lighting](feature_rgblight) | Enabled via `PIO` vendor driver |
| [Backlight](feature_backlight) | Forces [task driven PWM](feature_backlight#software-pwm-driver) until ARM can provide automatic configuration |
| [RGB Lighting](features/rgblight) | Enabled via `PIO` vendor driver |
| [Backlight](features/backlight) | Forces [task driven PWM](features/backlight#software-pwm-driver) until ARM can provide automatic configuration |
| USB Host (e.g. USB-USB converter) | Not supported (USB host code is AVR specific and is not currently supported on ARM) |
| [Split keyboards](feature_split_keyboard) | Partial via `PIO` vendor driver - heavily dependent on enabled features |
| [Split keyboards](features/split_keyboard) | Partial via `PIO` vendor driver - heavily dependent on enabled features |
### SparkFun Pro Micro - RP2040, Blok, Bit-C PRO and Michi {#promicro_rp2040 }

2
docs/feature_eeprom.md
View File

@ -109,7 +109,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
}
}
```
And lastly, you want to add the `eeconfig_init_user` function, so that when the EEPROM is reset, you can specify default values, and even custom actions. To force an EEPROM reset, use the `EE_CLR` keycode or [Bootmagic Lite](feature_bootmagic) functionallity. For example, if you want to set rgb layer indication by default, and save the default valued.
And lastly, you want to add the `eeconfig_init_user` function, so that when the EEPROM is reset, you can specify default values, and even custom actions. To force an EEPROM reset, use the `EE_CLR` keycode or [Bootmagic Lite](features/bootmagic) functionallity. For example, if you want to set rgb layer indication by default, and save the default valued.
```c
void eeconfig_init_user(void) { // EEPROM is getting reset!

4
docs/feature_layers.md
View File

@ -27,7 +27,7 @@ For a similar reason, the `layer` argument of `LM()` is also limited to layers 0
|:---------------:|:----------------------:|:------------------------:|:----------------:|
| ❌ | ❌ | ❌ | ✅ |
Expanding this would be complicated, at best. Moving to a 32-bit keycode would solve a lot of this, but would double the amount of space that the keymap matrix uses. And it could potentially cause issues, too. If you need to apply modifiers to your tapped keycode, [Tap Dance](feature_tap_dance#example-5-using-tap-dance-for-advanced-mod-tap-and-layer-tap-keys) can be used to accomplish this.
Expanding this would be complicated, at best. Moving to a 32-bit keycode would solve a lot of this, but would double the amount of space that the keymap matrix uses. And it could potentially cause issues, too. If you need to apply modifiers to your tapped keycode, [Tap Dance](features/tap_dance#example-5-using-tap-dance-for-advanced-mod-tap-and-layer-tap-keys) can be used to accomplish this.
## Working with Layers {#working-with-layers}
@ -104,7 +104,7 @@ This runs code every time that the layers get changed. This can be useful for l
### Example `layer_state_set_*` Implementation
This example shows how to set the [RGB Underglow](feature_rgblight) lights based on the layer, using the Planck as an example.
This example shows how to set the [RGB Underglow](features/rgblight) lights based on the layer, using the Planck as an example.
```c
layer_state_t layer_state_set_user(layer_state_t state) {

4
docs/feature_macros.md
View File

@ -86,7 +86,7 @@ All objects have one required key: `action`. This tells QMK what the object does
Only basic keycodes (prefixed by `KC_`) are supported. Do not include the `KC_` prefix when listing keycodes.
* `beep`
* Play a bell if the keyboard has [audio enabled](feature_audio).
* Play a bell if the keyboard has [audio enabled](features/audio).
* Example: `{"action": "beep"}`
* `delay`
* Pause macro playback. Duration is specified in milliseconds (ms).
@ -108,7 +108,7 @@ Only basic keycodes (prefixed by `KC_`) are supported. Do not include the `KC_`
### `SEND_STRING()` & `process_record_user`
See also: [Send String](feature_send_string)
See also: [Send String](features/send_string)
Sometimes you want a key to type out words or phrases. For the most common situations, we've provided `SEND_STRING()`, which will type out a string (i.e. a sequence of characters) for you. All ASCII characters that are easily translatable to a keycode are supported (e.g. `qmk 123\n\t`).

6
docs/feature_audio.md → docs/features/audio.md
View File

@ -27,7 +27,7 @@ per speaker is - for example with a piezo buzzer - the black lead to Ground, and
## ARM based boards
for more technical details, see the notes on [Audio driver](audio_driver).
for more technical details, see the notes on [Audio driver](../drivers/audio).
<!-- because I'm not sure where to fit this in: https://waveeditonline.com/ -->
### DAC (basic)
@ -196,7 +196,7 @@ These keycodes turn all of the audio functionality on and off. Turning it off m
|`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). |
|`DEFAULT_LAYER_SONGS` | *Not defined* |Plays song when switched default layers with [`set_single_persistent_default_layer(layer)`](../ref_functions#setting-the-persistent-default-layer)(quantum.c). |
|`SENDSTRING_BELL` | *Not defined* |Plays chime when the "enter" ("\a") character is sent (send_string.c) |
## Tempo
@ -354,7 +354,7 @@ You can configure the default, min and max frequencies, the stepping and built i
## MIDI Functionality
See [MIDI](feature_midi)
See [MIDI](midi)
## Audio Keycodes

8
docs/feature_auto_shift.md → docs/features/auto_shift.md
View File

@ -294,7 +294,7 @@ Holding and releasing a Tap Hold key without pressing another key will ordinaril
result in only the hold. With `retro shift` enabled this action will instead
produce a shifted version of the tap keycode on release.
It does not require [Retro Tapping](tap_hold#retro-tapping) to be enabled, and
It does not require [Retro Tapping](../tap_hold#retro-tapping) to be enabled, and
if both are enabled the state of `retro tapping` will only apply if the tap keycode
is not matched by Auto Shift. `RETRO_TAPPING_PER_KEY` and its corresponding
function, however, are checked before `retro shift` is applied.
@ -318,10 +318,10 @@ Without a value set, holds of any length without an interrupting key will produc
This value (if set) must be greater than one's `TAPPING_TERM`, as the key press
must be designated as a 'hold' by `process_tapping` before we send the modifier.
[Per-key tapping terms](tap_hold#tapping-term) can be used as a workaround.
[Per-key tapping terms](../tap_hold#tapping-term) can be used as a workaround.
There is no such limitation in regards to `AUTO_SHIFT_TIMEOUT` for normal keys.
**Note:** Tap Holds must be added to Auto Shift, see [here.](feature_auto_shift#auto-shift-per-key)
**Note:** Tap Holds must be added to Auto Shift, see [here.](auto_shift#auto-shift-per-key)
`IS_RETRO` may be helpful if one wants all Tap Holds retro shifted.
### Retro Shift and Tap Hold Configurations
@ -330,7 +330,7 @@ Tap Hold Configurations work a little differently when using Retro Shift.
Referencing `TAPPING_TERM` makes little sense, as holding longer would result in
shifting one of the keys.
`RETRO_SHIFT` enables [`PERMISSIVE_HOLD`-like behaviour](tap_hold#permissive-hold) (even if not explicitly enabled) on all mod-taps for which `RETRO_SHIFT` applies.
`RETRO_SHIFT` enables [`PERMISSIVE_HOLD`-like behaviour](../tap_hold#permissive-hold) (even if not explicitly enabled) on all mod-taps for which `RETRO_SHIFT` applies.
## Using Auto Shift Setup

2
docs/feature_autocorrect.md → docs/features/autocorrect.md
View File

@ -113,7 +113,7 @@ Additionally, you can use the `AC_TOGG` keycode to toggle the on/off status for
Callback function `bool process_autocorrect_user(uint16_t *keycode, keyrecord_t *record, uint8_t *typo_buffer_size, uint8_t *mods)` is available to customise incoming keycodes and handle exceptions. You can use this function to sanitise input before they are passed onto the autocorrect engine
::: tip
Sanitisation of input is required because autocorrect will only match 8-bit [basic keycodes](keycodes_basic) for typos. If valid modifier keys or 16-bit keycodes that are part of a user's word input (such as Shift + A) is passed through, they will fail typo letter detection. For example a [Mod-Tap](mod_tap) key such as `LCTL_T(KC_A)` is 16-bit and should be masked for the 8-bit `KC_A`.
Sanitisation of input is required because autocorrect will only match 8-bit [basic keycodes](../keycodes_basic) for typos. If valid modifier keys or 16-bit keycodes that are part of a user's word input (such as Shift + A) is passed through, they will fail typo letter detection. For example a [Mod-Tap](../mod_tap) key such as `LCTL_T(KC_A)` is 16-bit and should be masked for the 8-bit `KC_A`.
:::
The default user callback function is found inside `quantum/process_keycode/process_autocorrect.c`. It covers most use-cases for QMK special functions and quantum keycodes, including [overriding autocorrect](#overriding-autocorrect) with a modifier other than shift. The `process_autocorrect_user` function is `weak` defined to allow user's copy inside `keymap.c` (or code files) to overwrite it.

4
docs/feature_backlight.md → docs/features/backlight.md
View File

@ -1,6 +1,6 @@
# Backlighting {#backlighting}
Many keyboards support backlit keys by way of individual LEDs placed through or underneath the keyswitches. This feature is distinct from both the [RGB Underglow](feature_rgblight) and [RGB Matrix](feature_rgb_matrix) features as it usually allows for only a single colour per switch, though you can obviously install multiple different single coloured LEDs on a keyboard.
Many keyboards support backlit keys by way of individual LEDs placed through or underneath the keyswitches. This feature is distinct from both the [RGB Underglow](rgblight) and [RGB Matrix](rgb_matrix) features as it usually allows for only a single colour per switch, though you can obviously install multiple different single coloured LEDs on a keyboard.
QMK is able to control the brightness of these LEDs by switching them on and off rapidly in a certain ratio, a technique known as *Pulse Width Modulation*, or PWM. By altering the duty cycle of the PWM signal, it creates the illusion of dimming.
@ -153,7 +153,7 @@ The following `#define`s apply only to the `timer` driver:
|-----------------------|-------|----------------|
|`BACKLIGHT_PWM_TIMER` |`1` |The timer to use|
Note that the choice of timer may conflict with the [Audio](feature_audio) feature.
Note that the choice of timer may conflict with the [Audio](audio) feature.
## ChibiOS/ARM Configuration {#arm-configuration}

2
docs/feature_bluetooth.md → docs/features/bluetooth.md
View File

@ -26,7 +26,7 @@ A Bluefruit UART friend can be converted to an SPI friend, however this [require
<!-- FIXME: Document bluetooth support more completely. -->
## Bluetooth Rules.mk Options
The currently supported Bluetooth chipsets do not support [N-Key Rollover (NKRO)](reference_glossary#n-key-rollover-nkro), so `rules.mk` must contain `NKRO_ENABLE = no`.
The currently supported Bluetooth chipsets do not support [N-Key Rollover (NKRO)](../reference_glossary#n-key-rollover-nkro), so `rules.mk` must contain `NKRO_ENABLE = no`.
Add the following to your `rules.mk`:

6
docs/feature_bootmagic.md → docs/features/bootmagic.md
View File

@ -25,7 +25,7 @@ Using Bootmagic will **always reset** the EEPROM, so you will lose any settings
## Split Keyboards
When [handedness](feature_split_keyboard#setting-handedness) is predetermined via options like `SPLIT_HAND_PIN` or `EE_HANDS`, you might need to configure a different key between halves. To identify the correct key for the right half, examine the split key matrix defined in the `<keyboard>.h` file, e.g.:
When [handedness](split_keyboard#setting-handedness) is predetermined via options like `SPLIT_HAND_PIN` or `EE_HANDS`, you might need to configure a different key between halves. To identify the correct key for the right half, examine the split key matrix defined in the `<keyboard>.h` file, e.g.:
```c
#define LAYOUT_split_3x5_2( \
@ -80,6 +80,6 @@ You can define additional logic here. For instance, resetting the EEPROM or requ
## Addenda
To manipulate settings that were formerly configured through the now-deprecated full Bootmagic feature, see [Magic Keycodes](keycodes_magic).
To manipulate settings that were formerly configured through the now-deprecated full Bootmagic feature, see [Magic Keycodes](../keycodes_magic).
The Command feature, formerly known as Magic, also allows you to control different aspects of your keyboard. While it shares some functionality with Magic Keycodes, it also allows you to do things that Magic Keycodes cannot, such as printing version information to the console. For more information, see [Command](feature_command).
The Command feature, formerly known as Magic, also allows you to control different aspects of your keyboard. While it shares some functionality with Magic Keycodes, it also allows you to do things that Magic Keycodes cannot, such as printing version information to the console. For more information, see [Command](command).

4
docs/feature_caps_word.md → docs/features/caps_word.md
View File

@ -62,7 +62,7 @@ Next, use one the following methods to activate Caps Word:
* **Custom activation**: You can activate Caps Word from code by calling
`caps_word_on()`. This may be used to activate Caps Word through [a
combo](feature_combo) or [tap dance](feature_tap_dance) or any means
combo](combo) or [tap dance](tap_dance) or any means
you like.
### Troubleshooting: Command {#troubleshooting-command}
@ -71,7 +71,7 @@ When using `BOTH_SHIFTS_TURNS_ON_CAPS_WORD`, you might see a compile message
**"BOTH_SHIFTS_TURNS_ON_CAPS_WORD and Command should not be enabled at the same
time, since both use the Left Shift + Right Shift key combination."**
Many keyboards enable the [Command feature](feature_command), which by
Many keyboards enable the [Command feature](command), which by
default is also activated using the Left Shift + Right Shift key combination. To
fix this conflict, please disable Command by adding in rules.mk:

4
docs/feature_combo.md → docs/features/combo.md
View File

@ -18,7 +18,7 @@ combo_t key_combos[] = {
This will send "Escape" if you hit the A and B keys, and Ctrl+Z when you hit the C and D keys.
## Advanced Keycodes Support
Advanced keycodes, such as [Mod-Tap](mod_tap) and [Tap Dance](feature_tap_dance) are also supported together with combos. If you use these advanced keycodes in your keymap, you will need to place the full keycode in the combo definition, e.g.:
Advanced keycodes, such as [Mod-Tap](../mod_tap) and [Tap Dance](tap_dance) are also supported together with combos. If you use these advanced keycodes in your keymap, you will need to place the full keycode in the combo definition, e.g.:
```c
const uint16_t PROGMEM test_combo1[] = {LSFT_T(KC_A), LT(1, KC_B), COMBO_END};
@ -99,7 +99,7 @@ void process_combo_event(uint16_t combo_index, bool pressed) {
This will send "john.doe@example.com" if you chord E and M together, and clear the current line with Backspace and Left-Shift. You could change this to do stuff like play sounds or change settings.
It is worth noting that `COMBO_ACTION`s are not needed anymore. As of [PR#8591](https://github.com/qmk/qmk_firmware/pull/8591/), it is possible to run your own custom keycodes from combos. Just define the custom keycode, program its functionality in `process_record_user`, and define a combo with `COMBO(<key_array>, <your_custom_keycode>)`. See the first example in [Macros](feature_macros).
It is worth noting that `COMBO_ACTION`s are not needed anymore. As of [PR#8591](https://github.com/qmk/qmk_firmware/pull/8591/), it is possible to run your own custom keycodes from combos. Just define the custom keycode, program its functionality in `process_record_user`, and define a combo with `COMBO(<key_array>, <your_custom_keycode>)`. See the first example in [Macros](../feature_macros).
## Keycodes
You can enable, disable and toggle the Combo feature on the fly. This is useful if you need to disable them temporarily, such as for a game. The following keycodes are available for use in your `keymap.c`

2
docs/feature_command.md → docs/features/command.md
View File

@ -1,6 +1,6 @@
# Command
Command, formerly known as Magic, is a way to change your keyboard's behavior without having to flash or unplug it to use [Bootmagic Lite](feature_bootmagic). There is a lot of overlap between this functionality and the [Magic Keycodes](keycodes_magic). Wherever possible we encourage you to use that feature instead of Command.
Command, formerly known as Magic, is a way to change your keyboard's behavior without having to flash or unplug it to use [Bootmagic Lite](bootmagic). There is a lot of overlap between this functionality and the [Magic Keycodes](../keycodes_magic). Wherever possible we encourage you to use that feature instead of Command.
On some keyboards Command is disabled by default. If this is the case, it must be explicitly enabled in your `rules.mk`:

2
docs/feature_digitizer.md → docs/features/digitizer.md
View File

@ -1,6 +1,6 @@
# Digitizer {#digitizer}
Digitizers allow the mouse cursor to be placed at absolute coordinates, unlike the [Pointing Device](feature_pointing_device) feature which applies relative displacements.
Digitizers allow the mouse cursor to be placed at absolute coordinates, unlike the [Pointing Device](pointing_device) feature which applies relative displacements.
This feature implements a stylus device with a tip switch and barrel switch (generally equivalent to the primary and secondary mouse buttons respectively). Tip pressure is not currently implemented.

0
docs/feature_dip_switch.md → docs/features/dip_switch.md
View File

0
docs/feature_dynamic_macros.md → docs/features/dynamic_macros.md
View File

0
docs/feature_encoders.md → docs/features/encoders.md
View File

0
docs/feature_grave_esc.md → docs/features/grave_esc.md
View File

4
docs/feature_haptic_feedback.md → docs/features/haptic_feedback.md
View File

@ -192,11 +192,11 @@ The Haptic Exclusion is implemented as `__attribute__((weak)) bool get_haptic_en
With the entry of `#define NO_HAPTIC_MOD` in config.h, the following keys will not trigger feedback:
* Usual modifier keys such as Control/Shift/Alt/Gui (For example `KC_LCTL`)
* `MO()` momentary keys. See also [Layers](feature_layers).
* `MO()` momentary keys. See also [Layers](../feature_layers).
* `LM()` momentary keys with mod active.
* `LT()` layer tap keys, when held to activate a layer. However when tapped, and the key is quickly released, and sends a keycode, haptic feedback is still triggered.
* `TT()` layer tap toggle keys, when held to activate a layer. However when tapped `TAPPING_TOGGLE` times to permanently toggle the layer, on the last tap haptic feedback is still triggered.
* `MT()` mod tap keys, when held to keep a usual modifier key pressed. However when tapped, and the key is quickly released, and sends a keycode, haptic feedback is still triggered. See also [Mod-Tap](mod_tap).
* `MT()` mod tap keys, when held to keep a usual modifier key pressed. However when tapped, and the key is quickly released, and sends a keycode, haptic feedback is still triggered. See also [Mod-Tap](../mod_tap).
### NO_HAPTIC_ALPHA
With the entry of `#define NO_HAPTIC_ALPHA` in config.h, none of the alpha keys (A ... Z) will trigger a feedback.

0
docs/feature_hd44780.md → docs/features/hd44780.md
View File

2
docs/feature_joystick.md → docs/features/joystick.md
View File

@ -1,6 +1,6 @@
# Joystick {#joystick}
This feature provides game controller input as a joystick device supporting up to 6 axes and 32 buttons. Axes can be read either from an [ADC-capable input pin](adc_driver), or can be virtual, so that its value is provided by your code.
This feature provides game controller input as a joystick device supporting up to 6 axes and 32 buttons. Axes can be read either from an [ADC-capable input pin](../drivers/adc), or can be virtual, so that its value is provided by your code.
An analog device such as a [potentiometer](https://en.wikipedia.org/wiki/Potentiometer) found on an analog joystick's axes is based on a voltage divider, where adjusting the movable wiper controls the output voltage which can then be read by the microcontroller's ADC.

4
docs/feature_key_lock.md → docs/features/key_lock.md
View File

@ -16,8 +16,8 @@ First, enable Key Lock by setting `KEY_LOCK_ENABLE = yes` in your `rules.mk`. Th
## Caveats
Key Lock is only able to hold standard action keys and [One Shot modifier](one_shot_keys) keys (for example, if you have your Shift defined as `OSM(MOD_LSFT)`).
This does not include any of the QMK special functions (except One Shot modifiers), or shifted versions of keys such as `KC_LPRN`. If it's in the [Basic Keycodes](keycodes_basic) list, it can be held.
Key Lock is only able to hold standard action keys and [One Shot modifier](../one_shot_keys) keys (for example, if you have your Shift defined as `OSM(MOD_LSFT)`).
This does not include any of the QMK special functions (except One Shot modifiers), or shifted versions of keys such as `KC_LPRN`. If it's in the [Basic Keycodes](../keycodes_basic) list, it can be held.
Switching layers will not cancel the Key Lock. The Key Lock can be cancelled by calling the `cancel_key_lock()` function.

4
docs/feature_key_overrides.md → docs/features/key_overrides.md
View File

@ -103,7 +103,7 @@ const key_override_t **key_overrides = (const key_override_t *[]){
```
### Flexible macOS-friendly Grave Escape {#flexible-macos-friendly-grave-escape}
The [Grave Escape feature](feature_grave_esc) is limited in its configurability and has [bugs when used on macOS](feature_grave_esc#caveats). Key overrides can be used to achieve a similar functionality as Grave Escape, but with more customization and without bugs on macOS.
The [Grave Escape feature](grave_esc) is limited in its configurability and has [bugs when used on macOS](grave_esc#caveats). Key overrides can be used to achieve a similar functionality as Grave Escape, but with more customization and without bugs on macOS.
```c
// Shift + esc = ~
@ -224,7 +224,7 @@ The duration of the key repeat delay is controlled with the `KEY_OVERRIDE_REPEAT
## Difference to Combos {#difference-to-combos}
Note that key overrides are very different from [combos](feature_combo). Combos require that you press down several keys almost _at the same time_ and can work with any combination of non-modifier keys. Key overrides work like keyboard shortcuts (e.g. `ctrl` + `z`): They take combinations of _multiple_ modifiers and _one_ non-modifier key to then perform some custom action. Key overrides are implemented with much care to behave just like normal keyboard shortcuts would in regards to the order of pressed keys, timing, and interaction with other pressed keys. There are a number of optional settings that can be used to really fine-tune the behavior of each key override as well. Using key overrides also does not delay key input for regular key presses, which inherently happens in combos and may be undesirable.
Note that key overrides are very different from [combos](combo). Combos require that you press down several keys almost _at the same time_ and can work with any combination of non-modifier keys. Key overrides work like keyboard shortcuts (e.g. `ctrl` + `z`): They take combinations of _multiple_ modifiers and _one_ non-modifier key to then perform some custom action. Key overrides are implemented with much care to behave just like normal keyboard shortcuts would in regards to the order of pressed keys, timing, and interaction with other pressed keys. There are a number of optional settings that can be used to really fine-tune the behavior of each key override as well. Using key overrides also does not delay key input for regular key presses, which inherently happens in combos and may be undesirable.
## Solution to the problem of flashing modifiers {#neutralize-flashing-modifiers}

4
docs/feature_leader_key.md → docs/features/leader_key.md
View File

@ -1,6 +1,6 @@
# The Leader Key: A New Kind of Modifier {#the-leader-key}
If you're a Vim user, you probably know what a Leader key is. In contrast to [Combos](feature_combo), the Leader key allows you to hit a *sequence* of up to five keys instead, which triggers some custom functionality once complete.
If you're a Vim user, you probably know what a Leader key is. In contrast to [Combos](combo), the Leader key allows you to hit a *sequence* of up to five keys instead, which triggers some custom functionality once complete.
## Usage {#usage}
@ -86,7 +86,7 @@ Now, after you hit the leader key, you will have an infinite amount of time to s
### Strict Key Processing {#strict-key-processing}
By default, only the "tap keycode" portions of [Mod-Taps](mod_tap) and [Layer Taps](feature_layers#switching-and-toggling-layers) are added to the sequence buffer. This means if you press eg. `LT(3, KC_A)` as part of a sequence, `KC_A` will be added to the buffer, rather than the entire `LT(3, KC_A)` keycode.
By default, only the "tap keycode" portions of [Mod-Taps](../mod_tap) and [Layer Taps](../feature_layers#switching-and-toggling-layers) are added to the sequence buffer. This means if you press eg. `LT(3, KC_A)` as part of a sequence, `KC_A` will be added to the buffer, rather than the entire `LT(3, KC_A)` keycode.
This gives a more expected behaviour for most users, however you may want to change this.

2
docs/feature_led_indicators.md → docs/features/led_indicators.md
View File

@ -1,7 +1,7 @@
# LED Indicators
::: tip
LED indicators on split keyboards will require state information synced to the slave half (e.g. `#define SPLIT_LED_STATE_ENABLE`). See [data sync options](feature_split_keyboard#data-sync-options) for more details.
LED indicators on split keyboards will require state information synced to the slave half (e.g. `#define SPLIT_LED_STATE_ENABLE`). See [data sync options](split_keyboard#data-sync-options) for more details.
:::
QMK provides methods to read 5 of the LEDs defined in the HID spec:

2
docs/feature_led_matrix.md → docs/features/led_matrix.md
View File

@ -2,7 +2,7 @@
This feature allows you to use LED matrices driven by external drivers. It hooks into the backlight system so you can use the same keycodes as backlighting to control it.
If you want to use RGB LED's you should use the [RGB Matrix Subsystem](feature_rgb_matrix) instead.
If you want to use RGB LED's you should use the [RGB Matrix Subsystem](rgb_matrix) instead.
## Driver configuration {#driver-configuration}
---

2
docs/feature_midi.md → docs/features/midi.md
View File

@ -34,7 +34,7 @@ To enable advanced MIDI, add the following to your `config.h`:
If you're aiming to emulate the features of something like a Launchpad or other MIDI controller you'll need to access the internal MIDI device directly.
Because there are so many possible CC messages, not all of them are implemented as keycodes. Additionally, you might need to provide more than just two values that you would get from a keycode (pressed and released) - for example, the analog values from a fader or a potentiometer. So, you will need to implement [custom keycodes](feature_macros) if you want to use them in your keymap directly using `process_record_user()`.
Because there are so many possible CC messages, not all of them are implemented as keycodes. Additionally, you might need to provide more than just two values that you would get from a keycode (pressed and released) - for example, the analog values from a fader or a potentiometer. So, you will need to implement [custom keycodes](../feature_macros) if you want to use them in your keymap directly using `process_record_user()`.
For reference of all the possible control code numbers see [MIDI Specification](#midi-specification)

2
docs/feature_mouse_keys.md → docs/features/mouse_keys.md
View File

@ -205,4 +205,4 @@ Tips:
## Use with PS/2 Mouse and Pointing Device
Mouse keys button state is shared with [PS/2 mouse](feature_ps2_mouse) and [pointing device](feature_pointing_device) so mouse keys button presses can be used for clicks and drags.
Mouse keys button state is shared with [PS/2 mouse](ps2_mouse) and [pointing device](pointing_device) so mouse keys button presses can be used for clicks and drags.

0
docs/feature_oled_driver.md → docs/features/oled_driver.md
View File

0
docs/feature_os_detection.md → docs/features/os_detection.md
View File

8
docs/feature_pointing_device.md → docs/features/pointing_device.md
View File

@ -420,7 +420,7 @@ Any pointing device with a lift/contact status can integrate inertial cursor fea
## Split Keyboard Configuration
The following configuration options are only available when using `SPLIT_POINTING_ENABLE` see [data sync options](feature_split_keyboard#data-sync-options). The rotation and invert `*_RIGHT` options are only used with `POINTING_DEVICE_COMBINED`. If using `POINTING_DEVICE_LEFT` or `POINTING_DEVICE_RIGHT` use the common configuration above to configure your pointing device.
The following configuration options are only available when using `SPLIT_POINTING_ENABLE` see [data sync options](split_keyboard#data-sync-options). The rotation and invert `*_RIGHT` options are only used with `POINTING_DEVICE_COMBINED`. If using `POINTING_DEVICE_LEFT` or `POINTING_DEVICE_RIGHT` use the common configuration above to configure your pointing device.
| Setting | Description | Default |
| ------------------------------------ | ----------------------------------------------------------------------------------------------------- | ------------- |
@ -434,7 +434,7 @@ The following configuration options are only available when using `SPLIT_POINTIN
| `POINTING_DEVICE_INVERT_Y_RIGHT` | (Optional) Inverts the Y axis report. | _not defined_ |
::: warning
If there is a `_RIGHT` configuration option or callback, the [common configuration](feature_pointing_device#common-configuration) option will work for the left. For correct left/right detection you should setup a [handedness option](feature_split_keyboard#setting-handedness), `EE_HANDS` is usually a good option for an existing board that doesn't do handedness by hardware.
If there is a `_RIGHT` configuration option or callback, the [common configuration](pointing_device#common-configuration) option will work for the left. For correct left/right detection you should setup a [handedness option](split_keyboard#setting-handedness), `EE_HANDS` is usually a good option for an existing board that doesn't do handedness by hardware.
:::
@ -458,7 +458,7 @@ If there is a `_RIGHT` configuration option or callback, the [common configurati
## Split Keyboard Callbacks and Functions
The combined functions below are only available when using `SPLIT_POINTING_ENABLE` and `POINTING_DEVICE_COMBINED`. The 2 callbacks `pointing_device_task_combined_*` replace the single sided equivalents above. See the [combined pointing devices example](feature_pointing_device#combined-pointing-devices)
The combined functions below are only available when using `SPLIT_POINTING_ENABLE` and `POINTING_DEVICE_COMBINED`. The 2 callbacks `pointing_device_task_combined_*` replace the single sided equivalents above. See the [combined pointing devices example](pointing_device#combined-pointing-devices)
| Function | Description |
| --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
@ -684,7 +684,7 @@ If you are having issues with pointing device drivers debug messages can be enab
```
::: tip
The messages will be printed out to the `CONSOLE` output. For additional information, refer to [Debugging/Troubleshooting QMK](faq_debug).
The messages will be printed out to the `CONSOLE` output. For additional information, refer to [Debugging/Troubleshooting QMK](../faq_debug).
:::

0
docs/feature_programmable_button.md → docs/features/programmable_button.md
View File

0
docs/feature_ps2_mouse.md → docs/features/ps2_mouse.md
View File

0
docs/feature_rawhid.md → docs/features/rawhid.md
View File

9
docs/feature_repeat_key.md → docs/features/repeat_key.md
View File

@ -172,7 +172,7 @@ uint16_t get_alt_repeat_key_keycode_user(uint16_t keycode, uint8_t mods) {
#### Typing shortcuts
A useful possibility is having Alternate Repeat press [a
macro](feature_macros). This way macros can be used without having to
macro](../feature_macros). This way macros can be used without having to
dedicate keys to them. The following defines a couple shortcuts.
* Typing <kbd>K</kbd>, <kbd>Alt Repeat</kbd> produces "`keyboard`," with the
@ -281,11 +281,8 @@ bool remember_last_key_user(uint16_t keycode, keyrecord_t* record,
```
::: tip
See [Layer Functions](feature_layers#functions) and [Checking Modifier
See [Layer Functions](../feature_layers#functions) and [Checking Modifier State](../feature_advanced_keycodes#checking-modifier-state) for further details.
:::
State](feature_advanced_keycodes#checking-modifier-state) for further
details.
## Handle how a key is repeated
@ -388,7 +385,7 @@ By leveraging `get_last_keycode()` in macros, it is possible to define
additional, distinct "Alternate Repeat"-like keys. The following defines two
keys `ALTREP2` and `ALTREP3` and implements ten shortcuts with them for common
English 5-gram letter patterns, taking inspiration from
[Stenotype](feature_stenography):
[Stenotype](stenography):
| Typing | Produces | Typing | Produces |

10
docs/feature_rgb_matrix.md → docs/features/rgb_matrix.md
View File

@ -2,7 +2,7 @@
This feature allows you to use RGB LED matrices driven by external drivers. It hooks into the RGBLIGHT system so you can use the same keycodes as RGBLIGHT to control it.
If you want to use single color LED's you should use the [LED Matrix Subsystem](feature_led_matrix) instead.
If you want to use single color LED's you should use the [LED Matrix Subsystem](led_matrix) instead.
## Driver configuration {#driver-configuration}
---
@ -444,7 +444,7 @@ Configure the hardware via your `config.h`:
```
::: tip
There are additional configuration options for ARM controllers that offer increased performance over the default bitbang driver. Please see [WS2812 Driver](ws2812_driver) for more information.
There are additional configuration options for ARM controllers that offer increased performance over the default bitbang driver. Please see [WS2812 Driver](../drivers/ws2812) for more information.
:::
---
@ -619,7 +619,7 @@ All RGB keycodes are currently shared with the RGBLIGHT system:
::: warning
By default, if you have both the [RGB Light](feature_rgblight) and the RGB Matrix feature enabled, these keycodes will work for both features, at the same time. You can disable the keycode functionality by defining the `*_DISABLE_KEYCODES` option for the specific feature.
By default, if you have both the [RGB Light](rgblight) and the RGB Matrix feature enabled, these keycodes will work for both features, at the same time. You can disable the keycode functionality by defining the `*_DISABLE_KEYCODES` option for the specific feature.
:::
## RGB Matrix Effects {#rgb-matrix-effects}
@ -1060,7 +1060,7 @@ bool rgb_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max) {
```
::: tip
Split keyboards will require layer state data syncing with `#define SPLIT_LAYER_STATE_ENABLE`. See [Data Sync Options](feature_split_keyboard#data-sync-options) for more details.
Split keyboards will require layer state data syncing with `#define SPLIT_LAYER_STATE_ENABLE`. See [Data Sync Options](split_keyboard#data-sync-options) for more details.
:::
#### Examples {#indicator-examples-2}
@ -1105,7 +1105,7 @@ bool rgb_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max) {
```
::: tip
RGB indicators on split keyboards will require state information synced to the slave half (e.g. `#define SPLIT_LAYER_STATE_ENABLE`). See [data sync options](feature_split_keyboard#data-sync-options) for more details.
RGB indicators on split keyboards will require state information synced to the slave half (e.g. `#define SPLIT_LAYER_STATE_ENABLE`). See [data sync options](split_keyboard#data-sync-options) for more details.
:::
#### Indicators without RGB Matrix Effect

10
docs/feature_rgblight.md → docs/features/rgblight.md
View File

@ -23,7 +23,7 @@ RGBLIGHT_ENABLE = yes
```
::: tip
There are additional configuration options for ARM controllers that offer increased performance over the default WS2812 bitbang driver. Please see [WS2812 Driver](ws2812_driver) for more information.
There are additional configuration options for ARM controllers that offer increased performance over the default WS2812 bitbang driver. Please see [WS2812 Driver](../drivers/ws2812) for more information.
:::
For APA102 LEDs, add the following to your `rules.mk`:
@ -49,7 +49,7 @@ Then you should be able to use the keycodes below to change the RGB lighting to
QMK uses [Hue, Saturation, and Value](https://en.wikipedia.org/wiki/HSL_and_HSV) to select colors rather than RGB. The color wheel below demonstrates how this works.
<img src="./public/color-wheel.svg" alt="HSV Color Wheel" width="250"/>
<img src="../public/color-wheel.svg" alt="HSV Color Wheel" width="250"/>
Changing the **Hue** cycles around the circle.<br>
Changing the **Saturation** moves between the inner and outer sections of the wheel, affecting the intensity of the color.<br>
@ -87,7 +87,7 @@ Changing the **Value** sets the overall brightness.<br>
::: warning
By default, if you have both the RGB Light and the [RGB Matrix](feature_rgb_matrix) feature enabled, these keycodes will work for both features, at the same time. You can disable the keycode functionality by defining the `*_DISABLE_KEYCODES` option for the specific feature.
By default, if you have both the RGB Light and the [RGB Matrix](rgb_matrix) feature enabled, these keycodes will work for both features, at the same time. You can disable the keycode functionality by defining the `*_DISABLE_KEYCODES` option for the specific feature.
:::
## Configuration
@ -218,7 +218,7 @@ const uint8_t RGBLED_GRADIENT_RANGES[] PROGMEM = {255, 170, 127, 85, 64};
## Lighting Layers
::: tip
**Note:** Lighting Layers is an RGB Light feature, it will not work for RGB Matrix. See [RGB Matrix Indicators](feature_rgb_matrix#indicators) for details on how to do so.
**Note:** Lighting Layers is an RGB Light feature, it will not work for RGB Matrix. See [RGB Matrix Indicators](rgb_matrix#indicators) for details on how to do so.
:::
By including `#define RGBLIGHT_LAYERS` in your `config.h` file you can enable lighting layers. These make
@ -353,7 +353,7 @@ rgblight_blink_layer(2, 500);
```
::: warning
Lighting layers on split keyboards will require layer state synced to the slave half (e.g. `#define SPLIT_LAYER_STATE_ENABLE`). See [data sync options](feature_split_keyboard#data-sync-options) for more details.
Lighting layers on split keyboards will require layer state synced to the slave half (e.g. `#define SPLIT_LAYER_STATE_ENABLE`). See [data sync options](split_keyboard#data-sync-options) for more details.
:::
### Overriding RGB Lighting on/off status

2
docs/feature_secure.md → docs/features/secure.md
View File

@ -16,7 +16,7 @@ To unlock, the user must perform a set of actions. This can optionally be config
### 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).
The timeout can be refreshed by using the `secure_activity_event` function, for example from one of the various [hooks](../custom_quantum_functions).
## Usage

8
docs/feature_send_string.md → docs/features/send_string.md
View File

@ -5,7 +5,7 @@ The Send String API is part of QMK's macro system. It allows for sequences of ke
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.
Unicode characters are **not** supported with this API -- see the [Unicode](unicode) feature instead.
:::
## Usage {#usage}
@ -22,12 +22,12 @@ 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.|
|`SENDSTRING_BELL`|*Not defined* |If the [Audio](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_`.
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 |
|--------------|-------------------------------------------------------------------|
@ -48,7 +48,7 @@ The following characters are also mapped to their respective keycodes for conven
### 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).
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}

0
docs/feature_sequencer.md → docs/features/sequencer.md
View File

2
docs/feature_space_cadet.md → docs/features/space_cadet.md
View File

@ -24,7 +24,7 @@ Firstly, in your keymap, do one of the following:
## 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:
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](command) for info on how to change it, or make sure that Command is disabled in your `rules.mk` with:
```make
COMMAND_ENABLE = no

10
docs/feature_split_keyboard.md → docs/features/split_keyboard.md
View File

@ -20,12 +20,12 @@ Both sides must use the same MCU family, for eg two Pro Micro-compatible control
| Transport | AVR | ARM |
|------------------------------|--------------------|--------------------|
| ['serial'](serial_driver) | :heavy_check_mark: | :white_check_mark: <sup>1</sup> |
| ['serial'](../drivers/serial) | :heavy_check_mark: | :white_check_mark: <sup>1</sup> |
| I2C | :heavy_check_mark: | |
Notes:
1. Both hardware and software limitations are detailed within the [driver documentation](serial_driver).
1. Both hardware and software limitations are detailed within the [driver documentation](../drivers/serial).
## Hardware Configuration
@ -173,10 +173,10 @@ Some controllers (e.g. Blackpill with DFU compatible bootloader) will need to be
:::
::: tip
[QMK Toolbox]() can also be used to flash EEPROM handedness files. Place the controller in bootloader mode and select menu option Tools -> EEPROM -> Set Left/Right Hand
[QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases/) can also be used to flash EEPROM handedness files. Place the controller in bootloader mode and select menu option Tools -> EEPROM -> Set Left/Right Hand
:::
This setting is not changed when re-initializing the EEPROM using the `EE_CLR` key, or using the `eeconfig_init()` function. However, if you reset the EEPROM outside of the firmware's built in options (such as flashing a file that overwrites the `EEPROM`, like how the [QMK Toolbox]()'s "Reset EEPROM" button works), you'll need to re-flash the controller with the `EEPROM` files.
This setting is not changed when re-initializing the EEPROM using the `EE_CLR` key, or using the `eeconfig_init()` function. However, if you reset the EEPROM outside of the firmware's built in options (such as flashing a file that overwrites the `EEPROM`, like how the [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases/)'s "Reset EEPROM" button works), you'll need to re-flash the controller with the `EEPROM` files.
You can find the `EEPROM` files in the QMK firmware repo, [here](https://github.com/qmk/qmk_firmware/tree/master/quantum/split_common).
@ -307,7 +307,7 @@ This enables transmitting the current ST7565 on/off status to the slave side of
This enables transmitting the pointing device status to the master side of the split keyboard. The purpose of this feature is to enable use pointing devices on the slave side.
::: warning
There is additional required configuration for `SPLIT_POINTING_ENABLE` outlined in the [pointing device documentation](feature_pointing_device#split-keyboard-configuration).
There is additional required configuration for `SPLIT_POINTING_ENABLE` outlined in the [pointing device documentation](pointing_device#split-keyboard-configuration).
:::
```c

0
docs/feature_st7565.md → docs/features/st7565.md
View File

4
docs/feature_stenography.md → docs/features/stenography.md
View File

@ -25,7 +25,7 @@ Note: Due to hardware limitations, you might not be able to run both a virtual s
:::
::: warning
Serial stenography protocols are not supported on [V-USB keyboards](compatible_microcontrollers#atmel-avr).
Serial stenography protocols are not supported on [V-USB keyboards](../compatible_microcontrollers#atmel-avr).
:::
To enable stenography protocols, add the following lines to your `rules.mk`:
@ -94,7 +94,7 @@ STENO_ENABLE = yes
STENO_PROTOCOL = all
```
If you want to switch protocols programatically, as part of a custom macro for example, don't use `tap_code(QK_STENO_*)`, as `tap_code` only supports [basic keycodes](keycodes_basic). Instead, you should use `steno_set_mode(STENO_MODE_*)`, whose valid arguments are `STENO_MODE_BOLT` and `STENO_MODE_GEMINI`.
If you want to switch protocols programatically, as part of a custom macro for example, don't use `tap_code(QK_STENO_*)`, as `tap_code` only supports [basic keycodes](../keycodes_basic). Instead, you should use `steno_set_mode(STENO_MODE_*)`, whose valid arguments are `STENO_MODE_BOLT` and `STENO_MODE_GEMINI`.
The default protocol is Gemini PR but the last protocol used is stored in non-volatile memory so QMK will remember your choice between reboots of your keyboard &mdash; assuming that your keyboard features (emulated) EEPROM.

2
docs/feature_swap_hands.md → docs/features/swap_hands.md
View File

@ -30,7 +30,7 @@ Note that the array indices are reversed same as the matrix and the values are o
|`QK_SWAP_HANDS_TAP_TOGGLE` |`SH_TT` |Momentary swap when held, toggle when tapped |
|`QK_SWAP_HANDS_ONE_SHOT` |`SH_OS` |Turn on hand swap while held or until next key press|
`SH_TT` swap-hands tap-toggle key is similar to [layer tap-toggle](feature_layers#switching-and-toggling-layers). Tapping repeatedly (5 taps by default) will toggle swap-hands on or off, like `SH_TOGG`. Tap-toggle count can be changed by defining a value for `TAPPING_TOGGLE`.
`SH_TT` swap-hands tap-toggle key is similar to [layer tap-toggle](../feature_layers#switching-and-toggling-layers). Tapping repeatedly (5 taps by default) will toggle swap-hands on or off, like `SH_TOGG`. Tap-toggle count can be changed by defining a value for `TAPPING_TOGGLE`.
## Encoder Mapping

4
docs/feature_tap_dance.md → docs/features/tap_dance.md
View File

@ -17,7 +17,7 @@ Optionally, you might want to set a custom `TAPPING_TERM` time by adding somethi
#define TAPPING_TERM_PER_KEY
```
The `TAPPING_TERM` time is the maximum time allowed between taps of your Tap Dance key, and is measured in milliseconds. For example, if you used the above `#define` statement and set up a Tap Dance key that sends `Space` on single-tap and `Enter` on double-tap, then this key will send `ENT` only if you tap this key twice in less than 175ms. If you tap the key, wait more than 175ms, and tap the key again you'll end up sending `SPC SPC` instead. The `TAPPING_TERM_PER_KEY` definition is only needed if you control the tapping term through a [custom `get_tapping_term` function](tap_hold#tapping_term), which may be needed because `TAPPING_TERM` affects not just tap-dance keys.
The `TAPPING_TERM` time is the maximum time allowed between taps of your Tap Dance key, and is measured in milliseconds. For example, if you used the above `#define` statement and set up a Tap Dance key that sends `Space` on single-tap and `Enter` on double-tap, then this key will send `ENT` only if you tap this key twice in less than 175ms. If you tap the key, wait more than 175ms, and tap the key again you'll end up sending `SPC SPC` instead. The `TAPPING_TERM_PER_KEY` definition is only needed if you control the tapping term through a [custom `get_tapping_term` function](../tap_hold#tapping_term), which may be needed because `TAPPING_TERM` affects not just tap-dance keys.
Next, you will want to define some tap-dance keys, which is easiest to do with the `TD()` macro. That macro takes a number which will later be used as an index into the `tap_dance_actions` array and turns it into a tap-dance keycode.
@ -33,7 +33,7 @@ After this, you'll want to use the `tap_dance_actions` array to specify what act
The first option is enough for a lot of cases, that just want dual roles. For example, `ACTION_TAP_DANCE_DOUBLE(KC_SPC, KC_ENT)` will result in `Space` being sent on single-tap, `Enter` otherwise.
::: warning
Keep in mind that only [basic keycodes](keycodes_basic) are supported here. Custom keycodes are not supported.
Keep in mind that only [basic keycodes](../keycodes_basic) are supported here. Custom keycodes are not supported.
:::
Similar to the first option, the second and third option are good for simple layer-switching cases.

2
docs/feature_tri_layer.md → docs/features/tri_layer.md
View File

@ -8,7 +8,7 @@ TRI_LAYER_ENABLE = yes
Note that the "upper", "lower" and "adjust" names don't have a particular significance, they are just used to identify and clarify the behavior. Layers are processed from highest numeric value to lowest, however the values are not required to be consecutive.
For a detailed explanation of how the layer stack works, check out [Keymap Overview](keymap#keymap-and-layers).
For a detailed explanation of how the layer stack works, check out [Keymap Overview](../keymap#keymap-and-layers).
## Keycodes {#keycodes}

4
docs/feature_unicode.md → docs/features/unicode.md
View File

@ -31,7 +31,7 @@ Add the following to your `config.h`:
### Audio Feedback {#audio-feedback}
If you have the [Audio](feature_audio) feature enabled on your board, you can configure it to play sounds when the input mode is changed.
If you have the [Audio](audio) feature enabled on your board, you can configure it to play sounds when the input mode is changed.
Add the following to your `config.h`:
@ -199,7 +199,7 @@ Emacs supports code point input with the `insert-char` command.
**Mode Name:** `UNICODE_MODE_BSD`
Not currently implemented. If you're a BSD user and want to contribute support for this input mode, please [feel free](contributing)!
Not currently implemented. If you're a BSD user and want to contribute support for this input mode, please [feel free](../contributing)!
:::::

0
docs/feature_wpm.md → docs/features/wpm.md
View File

4
docs/flashing.md
View File

@ -53,7 +53,7 @@ QMK maintains [a fork of the LUFA DFU bootloader](https://github.com/qmk/lufa/tr
//#define QMK_LED E6
//#define QMK_SPEAKER C6
```
Currently we do not recommend making `QMK_ESC` the same key as the one designated for [Bootmagic Lite](feature_bootmagic), as holding it down will cause the MCU to loop back and forth between entering and exiting the bootloader.
Currently we do not recommend making `QMK_ESC` the same key as the one designated for [Bootmagic Lite](features/bootmagic), as holding it down will cause the MCU to loop back and forth between entering and exiting the bootloader.
The manufacturer and product strings are automatically pulled from `config.h`, with " Bootloader" appended to the product string.
@ -209,7 +209,7 @@ To enable the additional features, add the following defines to your `config.h`:
//#define QMK_SPEAKER C6
```
Currently we do not recommend making `QMK_ESC` the same key as the one designated for [Bootmagic Lite](feature_bootmagic), as holding it down will cause the MCU to loop back and forth between entering and exiting the bootloader.
Currently we do not recommend making `QMK_ESC` the same key as the one designated for [Bootmagic Lite](features/bootmagic), as holding it down will cause the MCU to loop back and forth between entering and exiting the bootloader.
The manufacturer and product strings are automatically pulled from `config.h`, with " Bootloader" appended to the product string.

6
docs/getting_started_make_guide.md
View File

@ -115,11 +115,11 @@ This allows you to send Unicode characters using `UM(<map index>)` in your keyma
This allows you to send Unicode characters by inputting a mnemonic corresponding to the character you want to send. You will need to maintain a mapping table in your keymap file. All possible code points (up to `0x10FFFF`) are supported.
For further details, as well as limitations, see the [Unicode page](feature_unicode).
For further details, as well as limitations, see the [Unicode page](features/unicode).
`AUDIO_ENABLE`
This allows you output audio on the C6 pin (needs abstracting). See the [audio page](feature_audio) for more information.
This allows you output audio on the C6 pin (needs abstracting). See the [audio page](features/audio) for more information.
`VARIABLE_TRACE`
@ -127,7 +127,7 @@ Use this to debug changes to variable values, see the [tracing variables](unit_t
`KEY_LOCK_ENABLE`
This enables [key lock](feature_key_lock).
This enables [key lock](features/key_lock).
`SPLIT_KEYBOARD`

2
docs/hand_wire.md
View File

@ -88,7 +88,7 @@ Note that these methods can be combined. Prepare your lengths of wire before mo
### A note on split keyboards
If you are planning a split keyboard (e.g. Dactyl) each half will require a controller and a means of communicating between them (like a TRRS or hardwired cable). Further information can be found in the [QMK split keyboard documentation.](feature_split_keyboard)
If you are planning a split keyboard (e.g. Dactyl) each half will require a controller and a means of communicating between them (like a TRRS or hardwired cable). Further information can be found in the [QMK split keyboard documentation.](features/split_keyboard)
### Soldering

10
docs/hardware_drivers.md
View File

@ -16,20 +16,20 @@ Support for addressing pins on the ProMicro by their Arduino name rather than th
## SSD1306 OLED Driver
Support for SSD1306 based OLED displays. For more information see the [OLED Driver Feature](feature_oled_driver) page.
Support for SSD1306 based OLED displays. For more information see the [OLED Driver Feature](features/oled_driver) page.
## WS2812
Support for WS2811/WS2812{a,b,c} LED's. For more information see the [RGB Light](feature_rgblight) page.
Support for WS2811/WS2812{a,b,c} LED's. For more information see the [RGB Light](features/rgblight) page.
## IS31FL3731
Support for up to 2 drivers. Each driver impliments 2 charlieplex matrices to individually address LEDs using I2C. This allows up to 144 same color LEDs or 32 RGB LEDs. For more information on how to setup the driver see the [RGB Matrix](feature_rgb_matrix) page.
Support for up to 2 drivers. Each driver impliments 2 charlieplex matrices to individually address LEDs using I2C. This allows up to 144 same color LEDs or 32 RGB LEDs. For more information on how to setup the driver see the [RGB Matrix](features/rgb_matrix) page.
## IS31FL3733
Support for up to a single driver with room for expansion. Each driver can control 192 individual LEDs or 64 RGB LEDs. For more information on how to setup the driver see the [RGB Matrix](feature_rgb_matrix) page.
Support for up to a single driver with room for expansion. Each driver can control 192 individual LEDs or 64 RGB LEDs. For more information on how to setup the driver see the [RGB Matrix](features/rgb_matrix) page.
## 24xx series external I2C EEPROM
Support for an external I2C-based EEPROM instead of using the on-chip EEPROM. For more information on how to setup the driver see the [EEPROM Driver](eeprom_driver) page.
Support for an external I2C-based EEPROM instead of using the on-chip EEPROM. For more information on how to setup the driver see the [EEPROM Driver](drivers/eeprom) page.

2
docs/hardware_keyboard_guidelines.md
View File

@ -230,7 +230,7 @@ Given the amount of functionality that QMK exposes it's very easy to confuse new
### Magic Keycodes and Command
[Magic Keycodes](keycodes_magic) and [Command](feature_command) are two related features that allow a user to control their keyboard in non-obvious ways. We recommend you think long and hard about if you're going to enable either feature, and how you will expose this functionality. Keep in mind that users who want this functionality can enable it in their personal keymaps without affecting all the novice users who may be using your keyboard as their first programmable board.
[Magic Keycodes](keycodes_magic) and [Command](features/command) are two related features that allow a user to control their keyboard in non-obvious ways. We recommend you think long and hard about if you're going to enable either feature, and how you will expose this functionality. Keep in mind that users who want this functionality can enable it in their personal keymaps without affecting all the novice users who may be using your keyboard as their first programmable board.
By far the most common problem new users encounter is accidentally triggering Bootmagic while they're plugging in their keyboard. They're holding the keyboard by the bottom, unknowingly pressing in alt and spacebar, and then they find that these keys have been swapped on them. We recommend leaving this feature disabled by default, but if you do turn it on consider setting `BOOTMAGIC_KEY_SALT` to a key that is hard to press while plugging your keyboard in.

42
docs/keycodes.md
View File

@ -233,7 +233,7 @@ See also: [Quantum Keycodes](quantum_keycodes#qmk-keycodes)
## Audio Keys {#audio-keys}
See also: [Audio](feature_audio)
See also: [Audio](features/audio)
|Key |Aliases |Description |
|-------------------------|---------|-------------------------------------------|
@ -255,7 +255,7 @@ See also: [Audio](feature_audio)
## Auto Shift {#auto-shift}
See also: [Auto Shift](feature_auto_shift)
See also: [Auto Shift](features/auto_shift)
|Key |Aliases |Description |
|----------------------|---------|--------------------------------------------|
@ -268,7 +268,7 @@ See also: [Auto Shift](feature_auto_shift)
## Autocorrect {#autocorrect}
See also: [Autocorrect](feature_autocorrect)
See also: [Autocorrect](features/autocorrect)
|Key |Aliases |Description |
|-----------------------|---------|----------------------------------------------|
@ -278,7 +278,7 @@ See also: [Autocorrect](feature_autocorrect)
## Backlighting {#backlighting}
See also: [Backlighting](feature_backlight)
See also: [Backlighting](features/backlight)
| Key | Aliases | Description |
|---------------------------------|-----------|-------------------------------------|
@ -292,7 +292,7 @@ See also: [Backlighting](feature_backlight)
## Bluetooth {#bluetooth}
See also: [Bluetooth](feature_bluetooth)
See also: [Bluetooth](features/bluetooth)
|Key |Aliases |Description |
|---------------------|---------|----------------------------------------------|
@ -302,7 +302,7 @@ See also: [Bluetooth](feature_bluetooth)
## Caps Word {#caps-word}
See also: [Caps Word](feature_caps_word)
See also: [Caps Word](features/caps_word)
|Key |Aliases |Description |
|---------------------|---------|------------------------------|
@ -310,7 +310,7 @@ See also: [Caps Word](feature_caps_word)
## Dynamic Macros {#dynamic-macros}
See also: [Dynamic Macros](feature_dynamic_macros)
See also: [Dynamic Macros](features/dynamic_macros)
|Key |Aliases |Description |
|---------------------------------|---------|--------------------------------------------------|
@ -322,7 +322,7 @@ See also: [Dynamic Macros](feature_dynamic_macros)
## Grave Escape {#grave-escape}
See also: [Grave Escape](feature_grave_esc)
See also: [Grave Escape](features/grave_esc)
|Key |Aliases |Description |
|-----------------|---------|------------------------------------------------------------------|
@ -330,7 +330,7 @@ See also: [Grave Escape](feature_grave_esc)
## Joystick {#joystick}
See also: [Joystick](feature_joystick)
See also: [Joystick](features/joystick)
|Key |Aliases|Description|
|-----------------------|-------|-----------|
@ -369,7 +369,7 @@ See also: [Joystick](feature_joystick)
## Key Lock {#key-lock}
See also: [Key Lock](feature_key_lock)
See also: [Key Lock](features/key_lock)
|Key |Description |
|---------|--------------------------------------------------------------|
@ -392,7 +392,7 @@ See also: [Layer Switching](feature_layers#switching-and-toggling-layers)
## Leader Key {#leader-key}
See also: [Leader Key](feature_leader_key)
See also: [Leader Key](features/leader_key)
|Key |Description |
|---------|------------------------|
@ -400,7 +400,7 @@ See also: [Leader Key](feature_leader_key)
## LED Matrix {#led-matrix}
See also: [LED Matrix](feature_led_matrix)
See also: [LED Matrix](features/led_matrix)
|Key |Aliases |Description |
|-------------------------------|---------|-----------------------------------|
@ -458,7 +458,7 @@ See also: [Magic Keycodes](keycodes_magic)
## MIDI {#midi}
See also: [MIDI](feature_midi)
See also: [MIDI](features/midi)
|Key |Aliases |Description |
|-------------------------------|------------------|---------------------------------|
@ -609,7 +609,7 @@ See also: [MIDI](feature_midi)
## Mouse Keys {#mouse-keys}
See also: [Mouse Keys](feature_mouse_keys)
See also: [Mouse Keys](features/mouse_keys)
|Key |Aliases |Description |
|----------------|---------|---------------------------|
@ -699,7 +699,7 @@ See also: [Dynamic Tapping Term](tap_hold#dynamic-tapping-term)
## RGB Lighting {#rgb-lighting}
See also: [RGB Lighting](feature_rgblight)
See also: [RGB Lighting](features/rgblight)
|Key |Aliases |Description |
|-------------------|----------|--------------------------------------------------------------------|
@ -724,7 +724,7 @@ See also: [RGB Lighting](feature_rgblight)
## RGB Matrix Lighting {#rgb-matrix-lighting}
See also: [RGB Matrix Lighting](feature_rgb_matrix)
See also: [RGB Matrix Lighting](features/rgb_matrix)
|Key |Aliases |Description |
|-------------------|----------|--------------------------------------------------------------------------------------|
@ -782,7 +782,7 @@ See also: [One Shot Keys](one_shot_keys)
## Programmable Button Support {#programmable-button}
See also: [Programmable Button](feature_programmable_button)
See also: [Programmable Button](features/programmable_button)
|Key |Aliases|Description |
|---------------------------|-------|----------------------|
@ -821,7 +821,7 @@ See also: [Programmable Button](feature_programmable_button)
## Repeat Key {#repeat-key}
See also: [Repeat Key](feature_repeat_key)
See also: [Repeat Key](features/repeat_key)
|Keycode |Aliases |Description |
|-----------------------|---------|-------------------------------------|
@ -830,7 +830,7 @@ See also: [Repeat Key](feature_repeat_key)
## Space Cadet {#space-cadet}
See also: [Space Cadet](feature_space_cadet)
See also: [Space Cadet](features/space_cadet)
|Key |Aliases |Description |
|----------------------------------------------|---------|----------------------------------------|
@ -844,7 +844,7 @@ See also: [Space Cadet](feature_space_cadet)
## Swap Hands {#swap-hands}
See also: [Swap Hands](feature_swap_hands)
See also: [Swap Hands](features/swap_hands)
|Key |Aliases |Description |
|-----------------------------|---------|----------------------------------------------------|
@ -859,7 +859,7 @@ See also: [Swap Hands](feature_swap_hands)
## Unicode Support {#unicode-support}
See also: [Unicode Support](feature_unicode)
See also: [Unicode Support](features/unicode)
|Key |Aliases |Description |
|----------------------------|---------|----------------------------------------------------------------|

2
docs/mod_tap.md
View File

@ -55,7 +55,7 @@ For convenience, QMK includes some Mod-Tap shortcuts to make common combinations
Currently, the `kc` argument of `MT()` is limited to the [Basic Keycode set](keycodes_basic), meaning you can't use keycodes like `LCTL()`, `KC_TILD`, or anything greater than `0xFF`. This is because QMK uses 16-bit keycodes, of which 3 bits are used for the function identifier, 1 bit for selecting right or left mods, and 4 bits to tell which mods are used, leaving only 8 bits for the keycode. Additionally, if at least one right-handed modifier is specified in a Mod-Tap, it will cause all modifiers specified to become right-handed, so it is not possible to mix and match the two - for example, Left Control and Right Shift would become Right Control and Right Shift.
Expanding this would be complicated, at best. Moving to a 32-bit keycode would solve a lot of this, but would double the amount of space that the keymap matrix uses. And it could potentially cause issues, too. If you need to apply modifiers to your tapped keycode, [Tap Dance](feature_tap_dance#example-5-using-tap-dance-for-advanced-mod-tap-and-layer-tap-keys) can be used to accomplish this.
Expanding this would be complicated, at best. Moving to a 32-bit keycode would solve a lot of this, but would double the amount of space that the keymap matrix uses. And it could potentially cause issues, too. If you need to apply modifiers to your tapped keycode, [Tap Dance](features/tap_dance#example-5-using-tap-dance-for-advanced-mod-tap-and-layer-tap-keys) can be used to accomplish this.
You may also run into issues when using Remote Desktop Connection on Windows. Because these keycodes send key events faster than a human, Remote Desktop could miss them.
To fix this, open Remote Desktop Connection, click on "Show Options", open the "Local Resources" tab, and in the keyboard section, change the drop down to "On this Computer". This will fix the issue, and allow the characters to work correctly.

4
docs/newbs_building_firmware.md
View File

@ -64,8 +64,8 @@ How to complete this step is entirely up to you. Make the one change that's been
* [Basic Keycodes](keycodes_basic)
* [Quantum Keycodes](quantum_keycodes)
* [Grave/Escape](feature_grave_esc)
* [Mouse keys](feature_mouse_keys)
* [Grave/Escape](features/grave_esc)
* [Mouse keys](features/mouse_keys)
::: tip
While you get a feel for how keymaps work, keep each change small. Bigger changes make it harder to debug any problems that arise.

30
docs/platformdev_rp2040.md
View File

@ -4,16 +4,16 @@ The following table shows the current driver status for peripherals on RP2040 MC
| System | Support |
| ---------------------------------------------------------------- | ---------------------------------------------- |
| [ADC driver](adc_driver) | :heavy_check_mark: |
| [Audio](audio_driver#pwm-hardware) | :heavy_check_mark: |
| [Backlight](feature_backlight) | :heavy_check_mark: |
| [I2C driver](i2c_driver) | :heavy_check_mark: |
| [SPI driver](spi_driver) | :heavy_check_mark: |
| [WS2812 driver](ws2812_driver) | :heavy_check_mark: using `PIO` driver |
| [External EEPROMs](eeprom_driver) | :heavy_check_mark: using `I2C` or `SPI` driver |
| [EEPROM emulation](eeprom_driver#wear_leveling-configuration) | :heavy_check_mark: |
| [serial driver](serial_driver) | :heavy_check_mark: using `SIO` or `PIO` driver |
| [UART driver](uart_driver) | :heavy_check_mark: using `SIO` driver |
| [ADC driver](drivers/adc) | :heavy_check_mark: |
| [Audio](drivers/audio#pwm-hardware) | :heavy_check_mark: |
| [Backlight](features/backlight) | :heavy_check_mark: |
| [I2C driver](drivers/i2c) | :heavy_check_mark: |
| [SPI driver](drivers/spi) | :heavy_check_mark: |
| [WS2812 driver](drivers/ws2812) | :heavy_check_mark: using `PIO` driver |
| [External EEPROMs](drivers/eeprom) | :heavy_check_mark: using `I2C` or `SPI` driver |
| [EEPROM emulation](drivers/eeprom#wear_leveling-configuration) | :heavy_check_mark: |
| [serial driver](drivers/serial) | :heavy_check_mark: using `SIO` or `PIO` driver |
| [UART driver](drivers/uart) | :heavy_check_mark: using `SIO` driver |
## GPIO
@ -43,7 +43,7 @@ QMK RP2040 support builds upon ChibiOS and thus follows their convention for act
| `I2C0` | `RP_I2C_USE_I2C0` | `I2CD0` |
| `I2C1` | `RP_I2C_USE_I2C1` | `I2CD1` |
To configure the I2C driver please read the [ChibiOS/ARM](i2c_driver#arm-configuration) section.
To configure the I2C driver please read the [ChibiOS/ARM](drivers/i2c#arm-configuration) section.
### SPI Driver
@ -52,7 +52,7 @@ To configure the I2C driver please read the [ChibiOS/ARM](i2c_driver#arm-configu
| `SPI0` | `RP_SPI_USE_SPI0` | `SPID0` |
| `SPI1` | `RP_SPI_USE_SPI1` | `SPID1` |
To configure the SPI driver please read the [ChibiOS/ARM](spi_driver#chibiosarm-configuration) section.
To configure the SPI driver please read the [ChibiOS/ARM](drivers/spi#chibiosarm-configuration) section.
### UART Driver
@ -92,7 +92,7 @@ This is the default board that is chosen, unless any other RP2040 board is selec
| `SPI_MISO_PIN` | `GP20` |
| `SPI_MOSI_PIN` | `GP19` |
| **Serial driver** | |
| `SERIAL_USART_DRIVER` ([SIO Driver](serial_driver#the-sio-driver) only) | `SIOD0` |
| `SERIAL_USART_DRIVER` ([SIO Driver](drivers/serial#the-sio-driver) only) | `SIOD0` |
| `SOFT_SERIAL_PIN` | undefined, use `SERIAL_USART_TX_PIN` |
| `SERIAL_USART_TX_PIN` | `GP0` |
| `SERIAL_USART_RX_PIN` | `GP1` |
@ -115,9 +115,9 @@ BOARD = GENERIC_RP_RP2040
## Split keyboard support
Split keyboards are fully supported using the [serial driver](serial_driver) in both full-duplex and half-duplex configurations. Two driver subsystems are supported by the RP2040, the hardware UART based `SIO` and the Programmable IO based `PIO` driver.
Split keyboards are fully supported using the [serial driver](drivers/serial) in both full-duplex and half-duplex configurations. Two driver subsystems are supported by the RP2040, the hardware UART based `SIO` and the Programmable IO based `PIO` driver.
| Feature | [SIO Driver](serial_driver#the-sio-driver) | [PIO Driver](serial_driver#the-pio-driver) |
| Feature | [SIO Driver](drivers/serial#the-sio-driver) | [PIO Driver](drivers/serial#the-pio-driver) |
| ----------------------------- | --------------------------------------------- | --------------------------------------------- |
| Half-Duplex operation | | :heavy_check_mark: |
| Full-Duplex operation | :heavy_check_mark: | :heavy_check_mark: |

2
docs/porting_your_keyboard_to_qmk.md
View File

@ -153,7 +153,7 @@ In the above example,
* `"matrix": [0, 0]` defines the electrical position
::: tip
See also: [Split Keyboard Layout Macro](feature_split_keyboard#layout-macro) and [Matrix to Physical Layout](understanding_qmk#matrix-to-physical-layout-map).
See also: [Split Keyboard Layout Macro](features/split_keyboard#layout-macro) and [Matrix to Physical Layout](understanding_qmk#matrix-to-physical-layout-map).
:::
## Additional Configuration

6
docs/pr_checklist.md
View File

@ -126,7 +126,7 @@ https://github.com/qmk/qmk_firmware/pulls?q=is%3Apr+is%3Aclosed+label%3Akeyboard
- commented-out functions removed too
- `matrix_init_board()` etc. migrated to `keyboard_pre_init_kb()`, see: [keyboard_pre_init*](custom_quantum_functions#keyboard_pre_init_-function-documentation)
- prefer `CUSTOM_MATRIX = lite` if custom matrix used, allows for standard debounce, see [custom matrix 'lite'](custom_matrix#lite)
- prefer LED indicator [Configuration Options](feature_led_indicators#configuration-options) to custom `led_update_*()` implementations where possible
- prefer LED indicator [Configuration Options](features/led_indicators#configuration-options) to custom `led_update_*()` implementations where possible
- hardware that's enabled at the keyboard level and requires configuration such as OLED displays or encoders should have basic functionality implemented here
- `<keyboard>.h`
- `#include "quantum.h"` appears at the top
@ -135,12 +135,12 @@ https://github.com/qmk/qmk_firmware/pulls?q=is%3Apr+is%3Aclosed+label%3Akeyboard
- no duplication of `rules.mk` or `config.h` from keyboard
- `keymaps/default/keymap.c`
- `QMKBEST`/`QMKURL` example macros removed
- if using `MO(1)` and `MO(2)` keycodes together to access a third layer, the [Tri Layer](feature_tri_layer) feature should be used, rather than manually implementing this using `layer_on/off()` and `update_tri_layer()` functions in the keymap's `process_record_user()`.
- if using `MO(1)` and `MO(2)` keycodes together to access a third layer, the [Tri Layer](features/tri_layer) feature should be used, rather than manually implementing this using `layer_on/off()` and `update_tri_layer()` functions in the keymap's `process_record_user()`.
- default (and via) keymaps should be "pristine"
- bare minimum to be used as a "clean slate" for another user to develop their own user-specific keymap
- what does pristine mean? no custom keycodes. no advanced features like tap dance or macros. basic mod taps and home row mods would be acceptable where their use is necessary
- standard layouts preferred in these keymaps, if possible
- should use [encoder map feature](feature_encoders#encoder-map), rather than `encoder_update_user()`
- should use [encoder map feature](features/encoders#encoder-map), rather than `encoder_update_user()`
- default keymap should not enable VIA -- the VIA integration documentation requires a keymap called `via`
- submitters can add an example (or bells-and-whistles) keymap showcasing capabilities in the same PR but it shouldn't be embedded in the 'default' keymap
- submitters can also have a "manufacturer-matching" keymap that mirrors existing functionality of the commercial product, if porting an existing board

4
docs/ref_functions.md
View File

@ -71,7 +71,7 @@ Do you want to set the default layer, so that it's retained even after you unplu
To use this, you would use `set_single_persistent_default_layer(layer)`. If you have a name defined for your layer, you can use that instead (such as _QWERTY, _DVORAK or _COLEMAK).
This will set the default layer, update the persistent settings, and play a tune if you have [Audio](feature_audio) enabled on your board, and the default layer sounds set.
This will set the default layer, update the persistent settings, and play a tune if you have [Audio](features/audio) enabled on your board, and the default layer sounds set.
To configure the default layer sounds, you would want to define this in your `config.h` file, like this:
@ -99,7 +99,7 @@ To reset to the bootloader use `QK_BOOTLOADER` or `QK_BOOT` keycode or `reset_ke
## Wiping the EEPROM (Persistent Storage)
If you're having issues with Audio, RGB Underglow, backlighting or keys acting weird, then you can reset the EEPROM (persistent setting storage). To force an EEPROM reset, use the [`EE_CLR` keycode](quantum_keycodes) or [Bootmagic Lite](feature_bootmagic) functionality. If neither of those are an option, then you can use a custom macro to do so.
If you're having issues with Audio, RGB Underglow, backlighting or keys acting weird, then you can reset the EEPROM (persistent setting storage). To force an EEPROM reset, use the [`EE_CLR` keycode](quantum_keycodes) or [Bootmagic Lite](features/bootmagic) functionality. If neither of those are an option, then you can use a custom macro to do so.
To wipe the EEPROM, run `eeconfig_init()` from your function or macro to reset most of the settings to default.

12
docs/reference_glossary.md
View File

@ -36,7 +36,7 @@ An alternative keyboard layout developed by Dr. August Dvorak in the 1930's. A s
## Dynamic Macro
A macro which has been recorded on the keyboard and which will be lost when the keyboard is unplugged or the computer rebooted.
* [Dynamic Macro Documentation](feature_dynamic_macros)
* [Dynamic Macro Documentation](features/dynamic_macros)
## Eclipse
An IDE that is popular with many C developers.
@ -76,7 +76,7 @@ An abstraction used to allow a key to serve multiple purposes. The highest activ
## Leader Key
A feature that allows you to tap the leader key followed by a sequence of 1, 2, or 3 keys to activate key presses or other quantum features.
* [Leader Key Documentation](feature_leader_key)
* [Leader Key Documentation](features/leader_key)
## LED
Light Emitting Diode, the most common device used for indicators on a keyboard.
@ -101,7 +101,7 @@ A key that is held down while typing another key to modify the action of that ke
## Mousekeys
A feature that lets you control your mouse cursor and click from your keyboard.
* [Mousekeys Documentation](feature_mouse_keys)
* [Mousekeys Documentation](features/mouse_keys)
## N-Key Rollover (NKRO)
A term that applies to keyboards that are capable of reporting any number of key-presses at once.
@ -130,7 +130,7 @@ A 1 byte number that is sent as part of a HID report over USB that represents a
## Space Cadet Shift
A special set of shift keys which allow you to type various types of braces by tapping the left or right shift one or more times.
* [Space Cadet Shift Documentation](feature_space_cadet)
* [Space Cadet Shift Documentation](features/space_cadet)
## Tap
Pressing and releasing a key. In some situations you will need to distinguish between a key down and a key up event, and Tap always refers to both at once.
@ -138,7 +138,7 @@ Pressing and releasing a key. In some situations you will need to distinguish be
## Tap Dance
A feature that lets you assign multiple keycodes to the same key based on how many times you press it.
* [Tap Dance Documentation](feature_tap_dance)
* [Tap Dance Documentation](features/tap_dance)
## Teensy
A low-cost AVR development board that is commonly used for hand-wired builds. A teensy is often chosen despite costing a few dollars more due to its halfkay bootloader, which makes flashing very simple.
@ -149,7 +149,7 @@ A generic term for LEDs that light the underside of the board. These LEDs typica
## Unicode
In the larger computer world Unicode is a set of encoding schemes for representing characters in any language. As it relates to QMK it means using various OS schemes to send unicode codepoints instead of scancodes.
* [Unicode Documentation](feature_unicode)
* [Unicode Documentation](features/unicode)
## Unit Testing
A framework for running automated tests against QMK. Unit testing helps us be confident that our changes do not break anything.

44
docs/reference_info_json.md
View File

@ -95,7 +95,7 @@ You can create `info.json` files at every level under `qmk_firmware/keyboards/<k
## APA102 {#apa102}
Configures the [APA102](apa102_driver) driver.
Configures the [APA102](drivers/apa102) driver.
* `apa102`
* `clock_pin` (Required)
@ -108,7 +108,7 @@ Configures the [APA102](apa102_driver) driver.
## Audio {#audio}
Configures the [Audio](feature_audio) feature.
Configures the [Audio](features/audio) feature.
* `audio`
* `default`
@ -138,7 +138,7 @@ Configures the [Audio](feature_audio) feature.
## Backlight {#backlight}
Configures the [Backlight](feature_backlight) feature.
Configures the [Backlight](features/backlight) feature.
* `backlight`
* `as_caps_lock`
@ -179,7 +179,7 @@ Configures the [Backlight](feature_backlight) feature.
## Bluetooth {#bluetooth}
Configures the [Bluetooth](feature_bluetooth) feature.
Configures the [Bluetooth](features/bluetooth) feature.
* `bluetooth`
* `driver`
@ -187,7 +187,7 @@ Configures the [Bluetooth](feature_bluetooth) feature.
## Bootmagic {#bootmagic}
Configures the [Bootmagic](feature_bootmagic) feature.
Configures the [Bootmagic](features/bootmagic) feature.
* `bootmagic`
* `enabled`
@ -199,7 +199,7 @@ Configures the [Bootmagic](feature_bootmagic) feature.
## Caps Word {#caps-word}
Configures the [Caps Word](feature_caps_word) feature.
Configures the [Caps Word](features/caps_word) feature.
* `caps_word`
* `both_shifts_turns_on`
@ -220,7 +220,7 @@ Configures the [Caps Word](feature_caps_word) feature.
## Combo {#combo}
Configures the [Combo](feature_combo) feature.
Configures the [Combo](features/combo) feature.
* `combo`
* `term`
@ -229,7 +229,7 @@ Configures the [Combo](feature_combo) feature.
## DIP Switches {#dip-switch}
Configures the [DIP Switches](feature_dip_switch) feature.
Configures the [DIP Switches](features/dip_switch) feature.
* `dip_switch`
* `enabled`
@ -243,7 +243,7 @@ Configures the [DIP Switches](feature_dip_switch) feature.
## EEPROM {#eeprom}
Configures the [EEPROM](eeprom_driver) driver.
Configures the [EEPROM](drivers/eeprom) driver.
* `eeprom`
* `driver`
@ -259,7 +259,7 @@ Configures the [EEPROM](eeprom_driver) driver.
## Encoder {#encoder}
Configures the [Encoder](feature_encoders) feature.
Configures the [Encoder](features/encoders) feature.
* `encoder`
* `rotary`
@ -274,7 +274,7 @@ Configures the [Encoder](feature_encoders) feature.
## Indicators {#indicators}
Configures the [LED Indicators](feature_led_indicators) feature.
Configures the [LED Indicators](features/led_indicators) feature.
* `indicators`
* `caps_lock`
@ -346,7 +346,7 @@ The ISO enter key is represented by a 1.25u×2uh key. Renderers which utilize in
## Leader Key {#leader-key}
Configures the [Leader Key](feature_leader_key) feature.
Configures the [Leader Key](features/leader_key) feature.
* `leader_key`
* `timing`
@ -361,7 +361,7 @@ Configures the [Leader Key](feature_leader_key) feature.
## LED Matrix {#led-matrix}
Configures the [LED Matrix](feature_led_matrix) feature.
Configures the [LED Matrix](features/led_matrix) feature.
* `led_matrix`
* `animations`
@ -474,7 +474,7 @@ Configures the [LED Matrix](feature_led_matrix) feature.
## Mouse Keys {#mouse-keys}
Configures the [Mouse Keys](feature_mouse_keys) feature.
Configures the [Mouse Keys](features/mouse_keys) feature.
* `mouse_key`
* `delay`
@ -498,7 +498,7 @@ Configures [One Shot keys](one_shot_keys).
## PS/2 {#ps2}
Configures the [PS/2](feature_ps2_mouse) feature.
Configures the [PS/2](features/ps2_mouse) feature.
* `ps2`
* `clock_pin`
@ -529,7 +529,7 @@ Configures the [PS/2](feature_ps2_mouse) feature.
## RGBLight {#rgblight}
Configures the [RGB Lighting](feature_rgblight) feature.
Configures the [RGB Lighting](features/rgblight) feature.
* `rgblight`
* `led_count` (Required)
@ -603,7 +603,7 @@ Configures the [RGB Lighting](feature_rgblight) feature.
## RGB Matrix {#rgb-matrix}
Configures the [RGB Matrix](feature_rgb_matrix) feature.
Configures the [RGB Matrix](features/rgb_matrix) feature.
* `rgb_matrix`
* `animations`
@ -688,7 +688,7 @@ Configures the [RGB Matrix](feature_rgb_matrix) feature.
## Secure {#secure}
Configures the [Secure](feature_secure) feature.
Configures the [Secure](features/secure) feature.
* `secure`
* `enabled`
@ -706,7 +706,7 @@ Configures the [Secure](feature_secure) feature.
## Split Keyboard {#split-keyboard}
Configures the [Split Keyboard](feature_split_keyboard) feature.
Configures the [Split Keyboard](features/split_keyboard) feature.
* `split`
* `bootmagic`
@ -745,7 +745,7 @@ Configures the [Split Keyboard](feature_split_keyboard) feature.
* Mirror the activity timestamps to the secondary half.
* Default: `false`
* `detected_os`
* Mirror the [detected OS](feature_os_detection) to the secondary half.
* Mirror the [detected OS](features/os_detection) to the secondary half.
* Default: `false`
* `haptic`
* Mirror the haptic state and process haptic feedback to the secondary half.
@ -788,7 +788,7 @@ Configures the [Split Keyboard](feature_split_keyboard) feature.
## Stenography {#stenography}
Configures the [Stenography](feature_stenography) feature.
Configures the [Stenography](features/stenography) feature.
* `stenography`
* `enabled`
@ -838,7 +838,7 @@ Configures the [Stenography](feature_stenography) feature.
## WS2812 {#ws2812}
Configures the [WS2812](ws2812_driver) driver.
Configures the [WS2812](drivers/ws2812) driver.
* `ws2812`
* `driver`

28
docs/syllabus.md
View File

@ -24,24 +24,24 @@ These topics start to dig into some of the features that QMK supports. You don't
* **Learn How To Configure Features**
<!-- * Configuration Overview FIXME(skullydazed/anyone): write this document -->
* [Audio](feature_audio)
* [Audio](features/audio)
* Lighting
* [Backlight](feature_backlight)
* [LED Matrix](feature_led_matrix)
* [RGB Lighting](feature_rgblight)
* [RGB Matrix](feature_rgb_matrix)
* [Backlight](features/backlight)
* [LED Matrix](features/led_matrix)
* [RGB Lighting](features/rgblight)
* [RGB Matrix](features/rgb_matrix)
* [Tap-Hold Configuration](tap_hold)
* [Squeezing Space from AVR](squeezing_avr)
* **Learn More About Keymaps**
* [Keymaps](keymap)
* [Custom Functions and Keycodes](custom_quantum_functions)
* Macros
* [Dynamic Macros](feature_dynamic_macros)
* [Dynamic Macros](features/dynamic_macros)
* [Compiled Macros](feature_macros)
* [Tap Dance](feature_tap_dance)
* [Combos](feature_combo)
* [Tap Dance](features/tap_dance)
* [Combos](features/combo)
* [Userspace](feature_userspace)
* [Key Overrides](feature_key_overrides)
* [Key Overrides](features/key_overrides)
# Advanced Topics
@ -53,15 +53,15 @@ Everything below here requires a lot of foundational knowledge. Besides being ab
* [info.json Reference](reference_info_json)
* [Debounce API](feature_debounce_type)
* **Advanced Features**
* [Unicode](feature_unicode)
* [Unicode](features/unicode)
* [API](api_overview)
* [Bootmagic Lite](feature_bootmagic)
* [Bootmagic Lite](features/bootmagic)
* **Hardware**
* [How Keyboards Work](how_keyboards_work)
* [How A Keyboard Matrix Works](how_a_matrix_works)
* [Split Keyboards](feature_split_keyboard)
* [Stenography](feature_stenography)
* [Pointing Devices](feature_pointing_device)
* [Split Keyboards](features/split_keyboard)
* [Stenography](features/stenography)
* [Pointing Devices](features/pointing_device)
* **Core Development**
* [Coding Conventions](coding_conventions_c)
* [Compatible Microcontrollers](compatible_microcontrollers)

2
docs/tap_hold.md
View File

@ -497,7 +497,7 @@ Do not use `MOD_xxx` constants like `MOD_LSFT` or `MOD_RALT`, since they're 5-bi
### Retro Shift
[Auto Shift,](feature_auto_shift) has its own version of `retro tapping` called `retro shift`. It is extremely similar to `retro tapping`, but holding the key past `AUTO_SHIFT_TIMEOUT` results in the value it sends being shifted. Other configurations also affect it differently; see [here](feature_auto_shift#retro-shift) for more information.
[Auto Shift,](features/auto_shift) has its own version of `retro tapping` called `retro shift`. It is extremely similar to `retro tapping`, but holding the key past `AUTO_SHIFT_TIMEOUT` results in the value it sends being shifted. Other configurations also affect it differently; see [here](features/auto_shift#retro-shift) for more information.
## Why do we include the key record for the per key functions?