add encoder matrix functionality

.github/ISSUE_TEMPLATE/blank.md

@@ -1,11 +1,5 @@
 ---
 name: Blank issue
-about: If you're 100% sure that you don't need one of the other issue templates, use
-  this one instead.
-title: ''
-labels: help wanted, question
-assignees: ''
+about: If you're 100% sure that you don't need one of the other issue templates, use this one instead. 
 
 ---
-
-

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,12 +1,7 @@
 ---
 name: Bug report
-about: Create a report to help us improve QMK Firmware.
-title: "[Bug] "
-labels: bug, help wanted, discussion
-assignees: ''
-
+about: Create a report to help us improve the QMK Firmware
 ---
-
 <!-- Provide a general summary of the bug in the title above. -->
 
 <!--- This template is entirely optional and can be removed, but is here to help both you and us. -->

.github/ISSUE_TEMPLATE/config.yml

@@ -1,8 +0,0 @@
-blank_issues_enabled: false
-contact_links:
-  - name: QMK Discord
-    url: https://discord.gg/Uq7gcHh
-    about: Ask questions, discuss issues and features. Chill.
-  - name: OLKB Subreddit
-    url: https://www.reddit.com/r/olkb
-    about: All things OLKB and QMK.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,12 +1,7 @@
 ---
 name: Feature request
-about: Suggest a new feature or changes to existing features.
-title: "[Feature Request] "
-labels: enhancement, help wanted, discussion
-assignees: ''
-
+about: Suggest a new feature or changes to existing features 
 ---
-
 <!--- Provide a general summary of the changes you want in the title above. -->
 
 <!--- This template is entirely optional and can be removed, but is here to help both you and us. -->

.github/ISSUE_TEMPLATE/other_issues.md

@@ -1,12 +1,7 @@
 ---
 name: Other issues
-about: Anything else that doesn't fall into the above categories.
-title: ''
-labels: help wanted, question, discussion
-assignees: ''
-
+about: Anything else that doesn't fall into the above categories. 
 ---
-
 <!--- Provide a general summary of the changes you want in the title above. -->
 
 <!--- Anything on lines wrapped in comments like these will not show up in the final text. -->

.github/stale.yml

@@ -1,52 +0,0 @@
-# Configuration for probot-stale - https://github.com/probot/stale
-
-# General configuration
-
-# Pull request specific configuration
-pulls:
-  staleLabel: awaiting changes
-  # Number of days of inactivity before an Issue or Pull Request becomes stale
-  daysUntilStale: 45
-  # Number of days of inactivity before a stale Issue or Pull Request is closed.
-  # Set to false to disable. If disabled, issues still need to be closed manually, but will remain marked as stale.
-  daysUntilClose: 30
-  # Comment to post when marking as stale. Set to `false` to disable
-  markComment: >
-    Thank you for your contribution!
-
-    This pull request has been automatically marked as stale because it has not had
-    activity in the last 45 days. It will be closed in 30 days if no further activity occurs.
-    Please feel free to give a status update now, or re-open when it's ready.
-  # Comment to post when closing a stale Issue or Pull Request.
-  closeComment: >
-    Thank you for your contribution!
-
-    This pull request has been automatically closed because it has not had activity in the last 30 days.
-    Please feel free to give a status update now, ping for review, or re-open when it's ready.
-  # Limit the number of actions per hour, from 1-30. Default is 30
-  limitPerRun: 30
-  exemptLabels:
-    - awaiting review
-    - breaking_change
-    - in progress
-    - on hold
-
-# Issue specific configuration
-issues:
-  staleLabel: solved
-  limitPerRun: 10
-  daysUntilStale: 90
-  daysUntilClose: 30
-  markComment: >
-    This issue has been automatically marked as resolved because it has not had activity in the
-    last 90 days. It will be closed in the next 30 days unless it is tagged properly or other activity
-    occurs.
-  closeComment: >
-    This issue has been automatically closed because it has not had activity in the last 30 days.
-    If this issue is still valid, re-open the issue and let us know.
-  exemptLabels:
-    - bug
-    - in progress
-    - on hold
-    - discussion
-    - to do

.travis.yml

@@ -16,7 +16,6 @@ install:
   - npm install -g moxygen
 script:
   - git rev-parse --short HEAD
-  - git diff --name-only HEAD $TRAVIS_BRANCH
   - bash util/travis_test.sh
   - bash util/travis_build.sh
   - bash util/travis_docs.sh

Makefile

@@ -272,14 +272,12 @@ define PARSE_RULE
     # If the rule starts with all, then continue the parsing from
     # PARSE_ALL_KEYBOARDS
     ifeq ($$(call COMPARE_AND_REMOVE_FROM_RULE,all),true)
-        KEYBOARD_RULE=all
         $$(eval $$(call PARSE_ALL_KEYBOARDS))
     else ifeq ($$(call COMPARE_AND_REMOVE_FROM_RULE,test),true)
         $$(eval $$(call PARSE_TEST))
     # If the rule starts with the name of a known keyboard, then continue
     # the parsing from PARSE_KEYBOARD
     else ifeq ($$(call TRY_TO_MATCH_RULE_FROM_LIST,$$(KEYBOARDS)),true)
-        KEYBOARD_RULE=$$(MATCHED_ITEM)
         $$(eval $$(call PARSE_KEYBOARD,$$(MATCHED_ITEM)))
     # Otherwise use the KEYBOARD variable, which is determined either by
     # the current directory you run make from, or passed in as an argument
@@ -382,9 +380,6 @@ define PARSE_KEYBOARD
     # Otherwise try to match the keymap from the current folder, or arguments to the make command
     else ifneq ($$(KEYMAP),)
         $$(eval $$(call PARSE_KEYMAP,$$(KEYMAP)))
-    # Otherwise if we are running make all:<user> just skip
-    else ifeq ($$(KEYBOARD_RULE),all)
-        # $$(info Skipping: No user keymap for $$(CURRENT_KB))
     # Otherwise, make all keymaps, again this is consistent with how it works without
     # any arguments
     else
@@ -563,10 +558,10 @@ endef
 	if ! python3 --version 1> /dev/null 2>&1; then printf "$(MSG_PYTHON_MISSING)"; fi
 	# Check if the submodules are dirty, and display a warning if they are
 ifndef SKIP_GIT
-	if [ ! -e lib/chibios ]; then git submodule sync lib/chibios && git submodule update --depth 50 --init lib/chibios; fi
-	if [ ! -e lib/chibios-contrib ]; then git submodule sync lib/chibios-contrib && git submodule update --depth 50 --init lib/chibios-contrib; fi
-	if [ ! -e lib/ugfx ]; then git submodule sync lib/ugfx && git submodule update --depth 50 --init lib/ugfx; fi
-	if [ ! -e lib/lufa ]; then git submodule sync lib/lufa && git submodule update --depth 50 --init lib/lufa; fi
+	if [ ! -e lib/chibios ]; then git submodule sync lib/chibios && git submodule update --depth 1 --init lib/chibios; fi
+	if [ ! -e lib/chibios-contrib ]; then git submodule sync lib/chibios-contrib && git submodule update --depth 1 --init lib/chibios-contrib; fi
+	if [ ! -e lib/ugfx ]; then git submodule sync lib/ugfx && git submodule update --depth 1 --init lib/ugfx; fi
+	if [ ! -e lib/lufa ]; then git submodule sync lib/lufa && git submodule update --depth 1 --init lib/lufa; fi
 	git submodule status --recursive 2>/dev/null | \
 	while IFS= read -r x; do \
 		case "$$x" in \

bin/qmk

@@ -26,7 +26,7 @@ with open(os.path.join(qmk_dir, 'requirements.txt'), 'r') as fd:
 
         module = line.split('=')[0] if '=' in line else line
         if not find_spec(module):
-            print('Could not find module %s!' % module)
+            print('Could not find module %s!', module)
             print('Please run `pip3 install -r requirements.txt` to install the python dependencies.')
             exit(255)
 

build_json.mk

@@ -22,5 +22,6 @@ else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_1)/keymap.json)","")
 endif
 
 # Generate the keymap.c
-$(KEYBOARD_OUTPUT)/src/keymap.c:
-	bin/qmk json-keymap --quiet --output $(KEYMAP_C) $(KEYMAP_JSON)
+ifneq ("$(KEYMAP_JSON)","")
+    _ = $(shell test -e $(KEYMAP_C) || bin/qmk json-keymap $(KEYMAP_JSON) -o $(KEYMAP_C))
+endif

common_features.mk

@@ -234,7 +234,7 @@ ifeq ($(strip $(BACKLIGHT_CUSTOM_DRIVER)), yes)
     BACKLIGHT_ENABLE = custom
 endif
 
-VALID_BACKLIGHT_TYPES := yes software custom
+VALID_BACKLIGHT_TYPES := yes custom
 
 BACKLIGHT_ENABLE ?= no
 ifneq ($(strip $(BACKLIGHT_ENABLE)), no)
@@ -246,22 +246,19 @@ ifneq ($(strip $(BACKLIGHT_ENABLE)), no)
         CIE1931_CURVE = yes
     endif
 
+
     COMMON_VPATH += $(QUANTUM_DIR)/backlight
     SRC += $(QUANTUM_DIR)/backlight/backlight.c
     OPT_DEFS += -DBACKLIGHT_ENABLE
 
-    ifeq ($(strip $(BACKLIGHT_ENABLE)), software)
-        SRC += $(QUANTUM_DIR)/backlight/backlight_soft.c
-    else
-        ifeq ($(strip $(BACKLIGHT_ENABLE)), custom)
-            OPT_DEFS += -DBACKLIGHT_CUSTOM_DRIVER
-        endif
+    ifeq ($(strip $(BACKLIGHT_ENABLE)), custom)
+        OPT_DEFS += -DBACKLIGHT_CUSTOM_DRIVER
+    endif
 
-        ifeq ($(PLATFORM),AVR)
-            SRC += $(QUANTUM_DIR)/backlight/backlight_avr.c
-        else
-            SRC += $(QUANTUM_DIR)/backlight/backlight_arm.c
-        endif
+    ifeq ($(PLATFORM),AVR)
+        SRC += $(QUANTUM_DIR)/backlight/backlight_avr.c
+    else
+        SRC += $(QUANTUM_DIR)/backlight/backlight_arm.c
     endif
 endif
 
@@ -407,12 +404,8 @@ ifeq ($(strip $(SPACE_CADET_ENABLE)), yes)
   OPT_DEFS += -DSPACE_CADET_ENABLE
 endif
 
+
 ifeq ($(strip $(DIP_SWITCH_ENABLE)), yes)
   SRC += $(QUANTUM_DIR)/dip_switch.c
   OPT_DEFS += -DDIP_SWITCH_ENABLE
 endif
-
-ifeq ($(strip $(DYNAMIC_MACRO_ENABLE)), yes)
-    SRC += $(QUANTUM_DIR)/process_keycode/process_dynamic_macro.c
-    OPT_DEFS += -DDYNAMIC_MACRO_ENABLE
-endif

docs/README.md

@@ -15,7 +15,7 @@ QMK (*Quantum Mechanical Keyboard*) is an open source community that maintains Q
 
 If you plan on contributing a keymap, keyboard, or features to QMK, the easiest thing to do is [fork the repo through Github](https://github.com/qmk/qmk_firmware#fork-destination-box), and clone your repo locally to make your changes, push them, then open a [Pull Request](https://github.com/qmk/qmk_firmware/pulls) from your fork.
 
-Otherwise, you can clone it directly with `git clone https://github.com/qmk/qmk_firmware`. Do not download the zip or tar files; a git repository is required to download the submodules in order to compile.
+Otherwise, you can either download it directly ([zip](https://github.com/qmk/qmk_firmware/zipball/master), [tar](https://github.com/qmk/qmk_firmware/tarball/master)), or clone it via git (`git@github.com:qmk/qmk_firmware.git`), or https (`https://github.com/qmk/qmk_firmware.git`).
 
 ## How to Compile
 

docs/_langs.md

@@ -1,8 +1,5 @@
 - Translations
   - [:uk: English](/)
   - [:cn: 中文](/zh-cn/)
-  - [:es: Español](/es/)
   - [:fr: Français](/fr-fr/)
-  - [:he: עברית](/he-il/)
   - [:ru: Русский](/ru-ru/)
-  - [:jp: 日本語](/ja/)

docs/_summary.md

@@ -33,7 +33,6 @@
   * [Keymap Overview](keymap.md)
 
 * [Hardware](hardware.md)
-  * [Compatible Microcontrollers](compatible_microcontrollers.md)
   * [AVR Processors](hardware_avr.md)
   * [Drivers](hardware_drivers.md)
 

docs/cli.md

@@ -95,30 +95,6 @@ qmk compile <configuratorExport.json>
 qmk compile -kb <keyboard_name> -km <keymap_name>
 ```
 
-## `qmk flash`
-
-This command is similar to `qmk compile`, but can also target a bootloader. The bootloader is optional, and is set to `:flash` by default.
-To specify a different bootloader, use `-bl <bootloader>`. Visit <https://docs.qmk.fm/#/flashing>
-for more details of the available bootloaders.
-
-**Usage for Configurator Exports**:
-
-```
-qmk flash <configuratorExport.json> -bl <bootloader>
-```
-
-**Usage for Keymaps**:
-
-```
-qmk flash -kb <keyboard_name> -km <keymap_name> -bl <bootloader>
-```
-
-**Listing the Bootloaders**
-
-```
-qmk flash -b
-```
-
 ## `qmk config`
 
 This command lets you configure the behavior of QMK. For the full `qmk config` documentation see [CLI Configuration](cli_configuration.md).
@@ -159,28 +135,6 @@ Creates a keymap.c from a QMK Configurator export.
 qmk json-keymap [-o OUTPUT] filename
 ```
 
-## `qmk kle2json`
-
-This command allows you to convert from raw KLE data to QMK Configurator JSON. It accepts either an absolute file path, or a file name in the current directory. By default it will not overwrite `info.json` if it is already present. Use the `-f` or `--force` flag to overwrite.
-
-**Usage**:
-
-```
-qmk kle2json [-f] <filename>
-```
-
-**Examples**:
-
-```
-$ qmk kle2json kle.txt 
-☒ File info.json already exists, use -f or --force to overwrite.
-```
-
-```
-$ qmk kle2json -f kle.txt -f
-Ψ Wrote out to info.json
-```
-
 ## `qmk list-keyboards`
 
 This command lists all the keyboards currently defined in `qmk_firmware`

docs/coding_conventions_python.md

@@ -77,9 +77,9 @@ Always use a .py filename extension. Never use dashes.
 
 ## Names to Avoid
 
-* single character names except for counters or iterators. You may use `e` as an exception identifier in try/except statements.
-* dashes (`-`) in any package/module name
-* `__double_leading_and_trailing_underscore__` names (reserved by Python)
+* single character names except for counters or iterators. You may use "e" as an exception identifier in try/except statements.
+* dashes (-) in any package/module name
+* __double_leading_and_trailing_underscore__ names (reserved by Python)
 
 # Docstrings
 

docs/compatible_microcontrollers.md

@@ -1,36 +1,25 @@
-# Compatible Microcontrollers
+# Atmel AVR
 
-QMK runs on any USB-capable AVR or ARM microcontroller with enough flash space - generally 32kB or more, though it will *just* squeeze into 16kB with most features disabled.
+QMK should run on any Atmel AVR processor with enough Flash. It has been tested on the following:
 
-## Atmel AVR
+* ATmega32U4 ([PJRC Teensy 2.0](http://www.pjrc.com/teensy/))
+* AT90USB1286 ([PJRC Teensy++ 2.0](http://www.pjrc.com/teensy/))
+* AT90USB1287 ([Atmel USBKEY](http://www.atmel.com/tools/AT90USBKEY.aspx))
+* ATmega168P with using [V-USB](http://www.obdev.at/products/vusb/index.html)
+* ATmega328P with using [V-USB](http://www.obdev.at/products/vusb/index.html)
+* ATmega32U2
+* AT90USB1286, 646, 647 should work
+* AT90USB162 testing...
 
-The following use [LUFA](https://www.fourwalledcubicle.com/LUFA.php) as the USB stack:
+NOTE: To enable full features of firmware you'll need 32KB flash size.
 
-* [ATmega16U2](https://www.microchip.com/wwwproducts/en/ATmega16U2) / [ATmega32U2](https://www.microchip.com/wwwproducts/en/ATmega32U2)
-* [ATmega16U4](https://www.microchip.com/wwwproducts/en/ATmega16U4) / [ATmega32U4](https://www.microchip.com/wwwproducts/en/ATmega32U4)
-* [AT90USB64](https://www.microchip.com/wwwproducts/en/AT90USB646) / [AT90USB128](https://www.microchip.com/wwwproducts/en/AT90USB1286)
+Please add any tested microcontrollers to this list.
 
-Certain MCUs which do not have native USB will use [V-USB](https://www.obdev.at/products/vusb/index.html) instead:
+# ARM
 
-* [ATmega32A](https://www.microchip.com/wwwproducts/en/ATmega32A)
-* [ATmega328P](https://www.microchip.com/wwwproducts/en/ATmega328P)
+You can also use any ARM processor that [ChibiOS](http://www.chibios.org) supports. The following processors have been tested:
 
-## ARM
-
-You can also use any ARM chip with USB that [ChibiOS](http://www.chibios.org) supports. Most have plenty of flash. Known to work are:
-
-### STMicroelectronics (STM32)
-
- * [STM32F0x2](https://www.st.com/en/microcontrollers-microprocessors/stm32f0x2.html)
- * [STM32F103](https://www.st.com/en/microcontrollers-microprocessors/stm32f103.html)
- * [STM32F303](https://www.st.com/en/microcontrollers-microprocessors/stm32f303.html)
-
-### NXP (Kinetis)
-
- * [MKL26Z64](https://www.nxp.com/products/processors-and-microcontrollers/arm-microcontrollers/general-purpose-mcus/kl-series-cortex-m0-plus/kinetis-kl2x-72-96-mhz-usb-ultra-low-power-microcontrollers-mcus-based-on-arm-cortex-m0-plus-core:KL2x)
- * [MK20DX128](https://www.nxp.com/products/processors-and-microcontrollers/arm-microcontrollers/general-purpose-mcus/k-series-cortex-m4/k2x-usb/kinetis-k20-50-mhz-full-speed-usb-mixed-signal-integration-microcontrollers-based-on-arm-cortex-m4-core:K20_50)
- * [MK20DX256](https://www.nxp.com/products/processors-and-microcontrollers/arm-microcontrollers/general-purpose-mcus/k-series-cortex-m4/k2x-usb/kinetis-k20-72-mhz-full-speed-usb-mixed-signal-integration-microcontrollers-mcus-based-on-arm-cortex-m4-core:K20_72)
-
-## Atmel ATSAM
-
-There is limited support for one of Atmel's ATSAM microcontrollers, that being the [ATSAMD51J18A](https://www.microchip.com/wwwproducts/en/ATSAMD51J18A) used by the [Massdrop keyboards](https://github.com/qmk/qmk_firmware/tree/master/keyboards/massdrop).
+* [Kinetis MKL26Z64](http://www.nxp.com/products/microcontrollers-and-processors/arm-processors/kinetis-cortex-m-mcus/l-series-ultra-low-power-m0-plus/kinetis-kl2x-48-mhz-usb-ultra-low-power-microcontrollers-mcus-based-on-arm-cortex-m0-plus-core:KL2x)
+* [Kinetis MK20DX128](http://www.nxp.com/assets/documents/data/en/data-sheets/K20P64M50SF0.pdf)
+* [Kinetis MK20DX128](http://www.nxp.com/assets/documents/data/en/data-sheets/K20P64M50SF0.pdf)
+* [Kinetis MK20DX256](http://www.nxp.com/products/microcontrollers-and-processors/arm-processors/kinetis-cortex-m-mcus/k-series-performance-m4/k2x-usb/kinetis-k20-72-mhz-full-speed-usb-mixed-signal-integration-microcontrollers-mcus-based-on-arm-cortex-m4-core:K20_72)

docs/config_options.md

@@ -196,8 +196,8 @@ If you define these options you will enable the associated feature, which may in
   * units to step when in/decreasing saturation
 * `#define RGBLIGHT_VAL_STEP 12`
   * units to step when in/decreasing value (brightness)
-* `#define RGBW`
-  * Enables RGBW LED support
+* `#define RGBW_BB_TWI`
+  * bit-bangs TWI to EZ RGBW LEDs (only required for Ergodox EZ)
 
 ## Mouse Key Options
 
@@ -348,8 +348,7 @@ Use these to enable or disable building certain features. The more you have enab
 * `NO_USB_STARTUP_CHECK`
   * Disables usb suspend check after keyboard startup. Usually the keyboard waits for the host to wake it up before any tasks are performed. This is useful for split keyboards as one half will not get a wakeup call but must send commands to the master.
 * `LINK_TIME_OPTIMIZATION_ENABLE`
-  * Enables Link Time Optimization (`LTO`) when compiling the keyboard.  This makes the process take longer, but can significantly reduce the compiled size (and since the firmware is small, the added time is not noticeable).  However, this will automatically disable the old Macros and Functions features automatically, as these break when `LTO` is enabled.  It does this by automatically defining `NO_ACTION_MACRO` and `NO_ACTION_FUNCTION`
-  * Alternatively, you can use `LTO_ENABLE` instead of `LINK_TIME_OPTIMIZATION_ENABLE`. 
+  = Enables Link Time Optimization (`LTO`) when compiling the keyboard.  This makes the process take longer, but can significantly reduce the compiled size (and since the firmware is small, the added time is not noticable).  However, this will automatically disable the old Macros and Functions features automatically, as these break when `LTO` is enabled.  It does this by automatically defining `NO_ACTION_MACRO` and `NO_ACTION_FUNCTION`
 
 ## USB Endpoint Limitations
 

docs/custom_quantum_functions.md

@@ -90,110 +90,68 @@ keyrecord_t record {
 
 # LED Control
 
-QMK provides methods to read 5 of the LEDs defined in the HID spec:
+QMK provides methods to read the 5 LEDs defined as part of the HID spec:
 
-* Num Lock
-* Caps Lock
-* Scroll Lock
-* Compose
-* Kana
+* `USB_LED_NUM_LOCK`
+* `USB_LED_CAPS_LOCK`
+* `USB_LED_SCROLL_LOCK`
+* `USB_LED_COMPOSE`
+* `USB_LED_KANA`
 
-There are two ways to get the lock LED state:
+These five constants correspond to the positional bits of the host LED state.
+There are two ways to get the host LED state:
 
-* by implementing `bool led_update_kb(led_t led_state)` or `_user(led_t led_state)`; or
-* by calling `led_t host_keyboard_led_state()`
+* by implementing `led_set_user()`
+* by calling `host_keyboard_leds()`
 
-!> `host_keyboard_led_state()` may already reflect a new value before `led_update_user()` is called.
+## `led_set_user()`
 
-Two more deprecated functions exist that provide the LED state as a `uint8_t`:
+This function will be called when the state of one of those 5 LEDs changes. It receives the LED state as a parameter.
+Use the `IS_LED_ON(usb_led, led_name)` and `IS_LED_OFF(usb_led, led_name)` macros to check the LED status.
 
-* `uint8_t led_set_kb(uint8_t usb_led)` and `_user(uint8_t usb_led)`
-* `uint8_t host_keyboard_leds()`
+!> `host_keyboard_leds()` may already reflect a new value before `led_set_user()` is called.
 
-## `led_update_user()`
-
-This function will be called when the state of one of those 5 LEDs changes. It receives the LED state as a struct parameter.
-
-You must return either `true` or `false` from this function, depending on whether you want to override the keyboard-level implementation.
-
-?> Because the `led_set_*` functions return `void` instead of `bool`, they do not allow for overriding the keyboard LED control, and thus it's recommended to use `led_update_*` instead.
-
-### Example `led_update_kb()` Implementation
+### Example `led_set_user()` Implementation
 
 ```c
-bool led_update_kb(led_t led_state) {
-    if(led_update_user(led_state)) {
-        if (led_state.num_lock) {
-            writePinLow(B0);
-        } else {
-            writePinHigh(B0);
-        }
-        if (led_state.caps_lock) {
-            writePinLow(B1);
-        } else {
-            writePinHigh(B1);
-        }
-        if (led_state.scroll_lock) {
-            writePinLow(B2);
-        } else {
-            writePinHigh(B2);
-        }
-        if (led_state.compose) {
-            writePinLow(B3);
-        } else {
-            writePinHigh(B3);
-        }
-        if (led_state.kana) {
-            writePinLow(B4);
-        } else {
-            writePinHigh(B4);
-        }
-        return true;
-    }
-}
-```
-
-### Example `led_update_user()` Implementation
-
-```c
-bool led_update_user(led_t led_state) {
-    if (led_state.num_lock) {
+void led_set_user(uint8_t usb_led) {
+    if (IS_LED_ON(usb_led, USB_LED_NUM_LOCK)) {
         writePinLow(B0);
     } else {
         writePinHigh(B0);
     }
-    if (led_state.caps_lock) {
+    if (IS_LED_ON(usb_led, USB_LED_CAPS_LOCK)) {
         writePinLow(B1);
     } else {
         writePinHigh(B1);
     }
-    if (led_state.scroll_lock) {
+    if (IS_LED_ON(usb_led, USB_LED_SCROLL_LOCK)) {
         writePinLow(B2);
     } else {
         writePinHigh(B2);
     }
-    if (led_state.compose) {
+    if (IS_LED_ON(usb_led, USB_LED_COMPOSE)) {
         writePinLow(B3);
     } else {
         writePinHigh(B3);
     }
-    if (led_state.kana) {
+    if (IS_LED_ON(usb_led, USB_LED_KANA)) {
         writePinLow(B4);
     } else {
         writePinHigh(B4);
     }
-    return true;
 }
 ```
 
-### `led_update_*` Function Documentation
+### `led_set_*` Function Documentation
 
-* Keyboard/Revision: `bool led_update_kb(led_t led_state)`
-* Keymap: `bool led_update_user(led_t led_state)`
+* Keyboard/Revision: `void led_set_kb(uint8_t usb_led)`
+* Keymap: `void led_set_user(uint8_t usb_led)`
 
-## `host_keyboard_led_state()`
+## `host_keyboard_leds()`
 
-Call this function to get the last received LED state as a `led_t`. This is useful for reading the LED state outside `led_update_*`, e.g. in [`matrix_scan_user()`](#matrix-scanning-code).
+Call this function to get the last received LED state. This is useful for reading the LED state outside `led_set_*`, e.g. in [`matrix_scan_user()`](#matrix-scanning-code).
+For convenience, you can use the `IS_HOST_LED_ON(led_name)` and `IS_HOST_LED_OFF(led_name)` macros instead of calling and checking `host_keyboard_leds()` directly.
 
 ## Setting Physical LED State
 

docs/de/README.md

@@ -1,33 +0,0 @@
-# Quantum Mechanical Keyboard Firmware
-
-[![Aktuelle Version](https://img.shields.io/github/tag/qmk/qmk_firmware.svg)](https://github.com/qmk/qmk_firmware/tags)
-[![Build Status](https://travis-ci.org/qmk/qmk_firmware.svg?branch=master)](https://travis-ci.org/qmk/qmk_firmware)
-[![Discord](https://img.shields.io/discord/440868230475677696.svg)](https://discord.gg/Uq7gcHh)
-[![Docs Status](https://img.shields.io/badge/docs-ready-orange.svg)](https://docs.qmk.fm)
-[![GitHub contributors](https://img.shields.io/github/contributors/qmk/qmk_firmware.svg)](https://github.com/qmk/qmk_firmware/pulse/monthly)
-[![GitHub forks](https://img.shields.io/github/forks/qmk/qmk_firmware.svg?style=social&label=Fork)](https://github.com/qmk/qmk_firmware/)
-
-## Was ist QMK Firmware?
-
-QMK (*Quantum Mechanical Keyboard*) ist eine Open-Source-Community, welche die QMK-Firmware, die QMK-Toolbox, [qmk.fm](https://qmk.fm) und diese Dokumententation betreut. QMK-Firmware ist eine Weiterentwicklung der [tmk\_keyboard](http://github.com/tmk/tmk_keyboard)-Tastatur-Firmware mit vielen nützlichen Zusatzfunktionen für Atmel AVR-Prozessoren. Ursprünglich wurde sie für Produkte von [OLKB](http://olkb.com), das [ErgoDox EZ](http://www.ergodox-ez.com) und das [Clueboard](http://clueboard.co/) entwickelt. Im Laufe der Zeit wurde sie mit Hilfe von [ChibiOS](http://chibios.org) auch für die ARM-Architektur angepasst. Außerdem ist es inzwischen möglich, auch handverdrahtete Tastaturen und selbst geätzte PCBs mit QMK zu verwenden.
-
-## Bezugsquelle für QMK
-
-Wenn Du vorhast, deine Tastatur, Tastaturbelegung oder Features zu QMK beizusteuern, geht das am einfachsten, indem Du das [Repository auf Github](https://github.com/qmk/qmk_firmware#fork-destination-box) forkst, die Änderungen in deinem lokalen Repo vornimmst und anschließend einen [Pull Request](https://github.com/qmk/qmk_firmware/pulls) einreichst.
-
-Ansonsten kannst Du es als [zip](https://github.com/qmk/qmk_firmware/zipball/master) oder [tar](https://github.com/qmk/qmk_firmware/tarball/master) herunterladen, oder es direkt via git klonen (`git clone git@github.com:qmk/qmk_firmware.git` bzw. `git clone https://github.com/qmk/qmk_firmware.git`).
-
-
-## Anleitung fürs Kompilieren
-
-Bevor Du in der Lage bist, die Firmware zu kompilieren, musst Du eine [Entwicklungsumgebung](de/getting_started_build_tools.md) für AVR und/oder ARM aufsetzen. Danach kannst Du mit dem `make` Befehl eine Keymap für deine Tastatur erzeugen. Die Notation dafür ist:
-
-    make planck/rev4:default
-
-Dies generiert die Revision `rev4` für eine Tastatur vom Type `planck` mit der `default` Tastaturbelegung. Nicht alle Tastaturen haben Revisionen (auch bekannt als Subprojekt oder Unterordner) weswegen dies auch ausgelassen werden kann:
-
-    make preonic:default
-
-## Möglichkeiten der Anpassung
-
-QMK hat viele [Features](de/features.md), die es zu entdecken gibt. In der [Dokumentation](https://docs.qmk.fmk) kannst Du Dir einen Überblick verschaffen. Die meisten Features basieren darauf, die [Tastaturbelegung](de/keymap.md) anzupassen und das Verhalten der [Keycodes](de/keycodes.md) zu verändern.

docs/de/_summary.md

@@ -1,121 +0,0 @@
-* [Anleitung für Anfänger](de/newbs.md)
-  * [Erste Schritte](de/newbs_getting_started.md)
-  * [Die erste Firmware](de/newbs_building_firmware.md)
-  * [Firmware flashen](de/newbs_flashing.md)
-  * [Testen und Debuggen](de/newbs_testing_debugging.md)
-  * [Git Tips und Tricks](de/newbs_best_practices.md)
-  * [Hilfreiche Ressourcen](de/newbs_learn_more_resources.md)
-
-* [QMK Basics](de/README.md)
-  * [QMK Einführung](de/getting_started_introduction.md)
-  * [QMK CLI](de/cli.md)
-  * [QMK CLI Konfiguration](de/cli_configuration.md)
-  * [Zu QMK beitragen](de/contributing.md)
-  * [Anleitung für Github](de/getting_started_github.md)
-  * [Nach Hilfe fragen](de/getting_started_getting_help.md)
-
-* [Breaking Changes](de/breaking_changes.md)
-  * [2019 Aug 30](de/ChangeLog/20190830.md)
-
-* [FAQ](de/faq.md)
-  * [Häufige Fragen](de/faq_general.md)
-  * [Build/Kompilieren](de/faq_build.md)
-  * [Debugging/Troubleshooting](de/faq_debug.md)
-  * [Keymap](de/faq_keymap.md)
-  * [Treiber Installation mit Zadig](de/driver_installation_zadig.md)
-
-* Detailierte Guides
-  * [Build Tools installieren](de/getting_started_build_tools.md)
-  * [Vagrant Guide](de/getting_started_vagrant.md)
-  * [Build/Compile Anleitung](de/getting_started_make_guide.md)
-  * [Firmware flashen](de/flashing.md)
-  * [Funktionalität anpassen](de/custom_quantum_functions.md)
-  * [Keymap Überblick](de/keymap.md)
-
-* [Hardware](de/hardware.md)
-  * [AVR Prozessoren](de/hardware_avr.md)
-  * [Treiber](de/hardware_drivers.md)
-
-* Referenz
-  * [Tastatur Richtlinien](de/hardware_keyboard_guidelines.md)
-  * [Konfigurations Optionen](de/config_options.md)
-  * [Keycodes](de/keycodes.md)
-  * [Coding Konventionen - C](de/coding_conventions_c.md)
-  * [Coding Konventionen - Python](de/coding_conventions_python.md)
-  * [Dokumentations Best Practices](de/documentation_best_practices.md)
-  * [Dokumentations Templates](de/documentation_templates.md)
-  * [Glossar](de/reference_glossary.md)
-  * [Unit Testing](de/unit_testing.md)
-  * [Nützliche Funktionen](de/ref_functions.md)
-  * [Configurator Support](de/reference_configurator_support.md)
-  * [info.json Format](de/reference_info_json.md)
-  * [Python CLI Development](de/cli_development.md)
-
-* [Features](de/features.md)
-  * [Basic Keycodes](de/keycodes_basic.md)
-  * [US ANSI Shifted Keys](de/keycodes_us_ansi_shifted.md)
-  * [Quantum Keycodes](de/quantum_keycodes.md)
-  * [Advanced Keycodes](de/feature_advanced_keycodes.md)
-  * [Audio](de/feature_audio.md)
-  * [Auto Shift](de/feature_auto_shift.md)
-  * [Backlight](de/feature_backlight.md)
-  * [Bluetooth](de/feature_bluetooth.md)
-  * [Bootmagic](de/feature_bootmagic.md)
-  * [Combos](de/feature_combo.md)
-  * [Command](de/feature_command.md)
-  * [Debounce API](de/feature_debounce_type.md)
-  * [DIP Switch](de/feature_dip_switch.md)
-  * [Dynamic Macros](de/feature_dynamic_macros.md)
-  * [Encoders](de/feature_encoders.md)
-  * [Grave Escape](de/feature_grave_esc.md)
-  * [Haptic Feedback](de/feature_haptic_feedback.md)
-  * [HD44780 LCD Controller](de/feature_hd44780.md)
-  * [Key Lock](de/feature_key_lock.md)
-  * [Layouts](de/feature_layouts.md)
-  * [Leader Key](de/feature_leader_key.md)
-  * [LED Matrix](de/feature_led_matrix.md)
-  * [Macros](de/feature_macros.md)
-  * [Mouse Keys](de/feature_mouse_keys.md)
-  * [OLED Driver](de/feature_oled_driver.md)
-  * [One Shot Keys](de/feature_advanced_keycodes.md#one-shot-keys)
-  * [Pointing Device](de/feature_pointing_device.md)
-  * [PS/2 Mouse](de/feature_ps2_mouse.md)
-  * [RGB Lighting](de/feature_rgblight.md)
-  * [RGB Matrix](de/feature_rgb_matrix.md)
-  * [Space Cadet](de/feature_space_cadet.md)
-  * [Split Keyboard](de/feature_split_keyboard.md)
-  * [Stenography](de/feature_stenography.md)
-  * [Swap Hands](de/feature_swap_hands.md)
-  * [Tap Dance](de/feature_tap_dance.md)
-  * [Terminal](de/feature_terminal.md)
-  * [Thermal Printer](de/feature_thermal_printer.md)
-  * [Unicode](de/feature_unicode.md)
-  * [Userspace](de/feature_userspace.md)
-  * [Velocikey](de/feature_velocikey.md)
-
-* Für Maker und Modder
-  * [Hand Wiring Guide](de/hand_wire.md)
-  * [ISP Flashing Guide](de/isp_flashing_guide.md)
-  * [ARM Debugging Guide](de/arm_debugging.md)
-  * [I2C Driver](de/i2c_driver.md)
-  * [GPIO Controls](de/internals_gpio_control.md)
-  * [Proton C Conversion](de/proton_c_conversion.md)
-
-* Für ein tieferes Verständnis
-  * [Wie Tastaturen funktionieren](de/how_keyboards_work.md)
-  * [QMK verstehen](de/understanding_qmk.md)
-
-* Andere Themen
-  * [Eclipse mit QMK](de/other_eclipse.md)
-  * [VSCode mit QMK](de/other_vscode.md)
-  * [Support](de/support.md)
-  * [Übersetzungen](de/translating.md)
-
-* QMK Internals (de/In Progress)
-  * [Defines](de/internals_defines.md)
-  * [Input Callback Reg](de/internals_input_callback_reg.md)
-  * [Midi Device](de/internals_midi_device.md)
-  * [Midi Device Setup Process](de/internals_midi_device_setup_process.md)
-  * [Midi Util](de/internals_midi_util.md)
-  * [Send Functions](de/internals_send_functions.md)
-  * [Sysex Tools](de/internals_sysex_tools.md)

docs/de/driver_installation_zadig.md

@@ -1,47 +0,0 @@
-# Bootloader Treiber Installation mit Zadig
-
-QMK erscheint für den Host als normales HID Eingabegerät und benötigt deshalb keine zusätzlichen Treiber. Der Bootloader, den Du für das Flashen der Firmware benötigst, jedoch meistens schon.
-
-Hierzu gibt es zwei Ausnahmen: den Caterina Bootloader, meistens auf Pro Micros, sowie den HalfKay Bootloader auf PJRC Teensys. Diese erscheinen als serieller Port und als generisches HID Gerät und benötigen keine Treiber.
-
-Wir empfehlen deshalb [Zadig](https://zadig.akeo.ie/). Wenn Du die Entwicklungsumgebung mit MSYS2 oder WSL installiert hast, wird dich dass `qmk_install.sh` Skript gefragt haben, ob es die Treiber für dich installieren sollte.
-
-## Installation
-
-Versetze deine Tastatur in den Bootloader-Modus, entweder durch Betätigung des physischen `RESET` Schalters - meist auf der Unterseite der Platine - oder durch das Auslösen des Key-Codes `RESET` bzw. `KC_RESET` (sollte in der zur Tastatur gehörigen `keycode.c` zu entnehmen sein). Sollte deine Tastatur weder noch besitzen, versuche es damit die `Escape`-Taste oder `Leertaste + B` zu halten während Du die Tastatur mit dem PC verbindest (Siehe auch [Bootmagic](de/feature_bootmagic.md) für weitere Details). Ein paar Tastaturen benutzen das [Command](de/feature_command.md)-Feature an Stelle von Bootmagic; in diesem Fall kannst du mit den Tastenkombinationen `linkes Shift + rechtes Shift + B` oder `linkes Shift + rechtes Shift + Escape` zu jeder Zeit in den Bootloader wechseln solange die Tastatur verbunden ist.
-
-Eingie Tastaturen haben u.U. spezielle Anweisungen um in den Bootloader-Modus zu gelangen. Zum Beispiel kann die [Bootmagic-Lite](de/feature_bootmagic.md#bootmagic-lite)-Taste (default: Escape) auf eine andere Taste gemappt sein; oder die magische Kombination (default: linkes Shift+rechtes Shift) verwendet anstatt Shift die STRG-Tasten. Die zur Tastatur gehörige README sollte dir Aufschluss darüber geben wie der Bootloader-Modus ausgelöst werden kann wenn Du unsicher bist.
-
-Um ein Gerät mit USBaspLoader in den Bootloader-Modus zu versetzen, halte `BOOT` gedrückt während Du den `RESET`-Knopf drückst.
-Alternativ, halte `BOOT` gedrückt während Du das USB-Kabel einsteckst.
-
-Zadig sollte das Bootloader-Gerät automatisch erkennen. Manchmal musst Du zusätzlich noch **Options → List All Devices** auswählen.
-
- - Tastaturen mit Atmel AVR MCUs sollten als `ATm32U4DFU` (oder ähnlich) angezeigt werden, mit der Vendor ID `03EB`.
- - USBasp werden als `USBasp` angezeigt, mit VID/PID `16C0:05DC`.
- - Tastaturen AVR controller und dem QMK-DFU Bootloader haben den namen `<Tastatur Name> Bootloader` und die VID `03EB`.
- - Die meisten ARM Tastaturen werden als `STM32 BOOTLOADER` angezeigt, mit VID/PID `0483:DF11`.
-
-!> Sollte Zadig ein oder mehrere Geräte mit `HidUsb`-Treiber anzeigen, dann ist deine Tastatur wahrscheinlich nicht im Bootloader-Modus. Der Pfeil wird orange eingefärbt sein und Du wirst nach einer Bestätigung gefragt um Veränderungen am System vorzunehmen. In diesem Fall **fahre nicht fort**!
-
-Wenn der Pfeil grün angezeigt wird, wähle den Treiber aus und klicke auf **Treiber installieren**. Der  `libusb-win32`-Treiber sollte gewöhnlich für AVR verwendet werden und `WinUSB` für ARM. Sollte es danach noch nicht möglich sein die Tastatur zu flashen, versuche es mit einem anderen Treiber. Für USBaspLoader Geräte, die über die Befehlszeile mit MSYS2 geflasht werden, wird der `libusbk`-Treiber empfohlen. Ansonsten sollte `libusb-win32` funktionieren wenn die QMK Toolbox verwendet wird.
-
-![Zadig mit Bootloader-Treiber korrekt installiert](https://i.imgur.com/b8VgXzx.png)
-
-Entferne nun deine Tastatur und verbinde sie erneut um sicherzugehen dass der neue Treiber erfolgreich installiert wurde. Wenn Du QMK Toolbox benutzt, starte die Anwendung zur Sicherheit einmal neu, da Veränderungen am Treiber manchmal nicht richtig erkannt werden. Wenn dies immer noch nicht erfolgreich war hilft es an dieser Stelle manchmal ein Neustart des Computers.
-
-## Wiederherstellung einer Installation für ein falsches Gerät
-
-Wenn Du feststellst dass Du anschließend auf deiner Tastatur nicht mehr tippen kannst, ist etwas bei der Installation schief gelaufen. Ein häufiger Fehler ist es dass die Tastatur nicht im Bootloader-Modus war und stattdessen der Treiber für das HID-Gerät ersetzt wurde. Dies kannst Du einfach mit Zadig überprüfen, eine funktionierende Tastatur verwendet als Treiber `HidUsb` auf allen Interfaces .
-
-![Eine funktionierende Tastatur aus Zadigs Sicht](https://i.imgur.com/Hx0E5kC.png)
-
-Öffne den Geräte-Manager und suche nach einem Gerät das wie deine Tastatur aussieht.
-
-![Die Tastatur mit dem falschen Treiber installiert, im Geräte-Manager](https://i.imgur.com/L3wvX8f.png)
-
-Rechtsklick und **Gerät deinstallieren** anklicken. Bitte gehe sicher dass in diesem Schritt auch **Treibersoftware für dieses Gerät löschen** markiert ist.
-
-![Der "Gerät deinstallieren"-Dialog, mit "Treibersoftware für dieses Gerät entfernen" markiert](https://i.imgur.com/aEs2RuA.png)
-
-Klick **Aktion → Suche nach veränderter Hardware**. Nun solltest Du wieder in der Lage sein normal zu tippen. Vergewissere dich mit Hilfe von Zadig dass die Tastatur nun `HidUsb` als Treiber verwendet. Wenn dies der Fall ist sollte wieder alles funktionieren.

docs/de/newbs.md

@@ -1,22 +0,0 @@
-# Anleitung für absolute Beginner
-QMK ist eine mächtige Open Source Firmware für mechanische Tastaturen. Mit QMK kannst Du deine Tastatur sowohl sehr einfach als auch sehr umfangreich anpassen. Menschen unterschiedlichen Wissensstandes - vom kompletten Anfänger bis zum erfahrenen Programmierer - haben ihre Tastaturen mit QMK erfolgreich auf ihre persönlichen Bedürfnisse angepasst. Diese Anleitung soll Dir unabhängig von deinen Vorkenntnissen dabei helfen dies ebenfalls zu bewältigen.
-
-Bist Du unsicher ob deine Tastatur QMK unterstützt? Wenn es eine mechanische Tastatur ist, die Du selbst gebaut hast, stehen deine Chancen gut. Wir unterstützen eine [Vielzahl](https://qmk.fm/keyboards/) selbst gebauter Tastaturen, sodass selbst wenn deine jetzige Tastatur nicht unterstützt wird Du keine Probleme haben solltest eine für deine Anforderungen zu finden.
-
-## Übersicht
-
-Diese Anleitung ist in 7 Abschnitte unterteilt:
-
-* [Die ersten Schritte](newbs_getting_started.md)
-* [Die erste Firmware auf der Kommandozeile erzeugen](newbs_building_firmware.md)
-* [Die erste Firmware mit der Online GUI erzeugen](newbs_building_firmware_configurator.md)
-* [Firmware flashen](newbs_flashing.md)
-* [Testen und Debuggen](newbs_testing_debugging.md)
-* [Git Leitfaden](newbs_best_practices.md)
-* [Weitere hilfreiche Ressourcen für Anfänger](newbs_learn_more_resources.md)
-
-Diese Anleitung richtet sich an Personen, die vorher noch nie Software kompiliert haben. Die Entscheidungen und Empfehlungen basieren auf dieser Grundannahme. Es gibt unterschiedliche Herangehensweisen für viele der Prozeduren und wir unterstützen die meisten Alternativen. Wenn Du mal nicht weiter weißt oder Dir nicht sicher bist, wie Du an ein Problem herangehen sollst, kannst Du uns gerne [um Hilfe bitten](getting_started_getting_help.md).
-
-## Weitere Ressourcen
-
-* [Thomas Baart's QMK Basics Blog](https://thomasbaart.nl/category/mechanical-keyboards/firmware/qmk/qmk-basics/) – Ein äußerst hilfreicher Blog eines Community-Mitglieds, der einige Grundlagen der QMK-Firmware aus der Sicht des Benutzers erklärt (auf Englisch).

docs/de/newbs_building_firmware.md

@@ -1,78 +0,0 @@
-# Eine eigene Firmware erstellen 
-
-Nachdem Du nun eine funktionierende Entwicklungsumgebung aufgesetzt hast, bist Du nun bereit, deine eigene Firmware zu erstellen. Dieses Sektion des Guides wird zwischen drei Programmen hin- und herwechseln: deinem Dateimanager, deinem Texteditor und der Befehlszeile. Lasse diese drei Fenster geöffnet, bis Du fertig und zufrieden mit deiner Tastatur-Firmware bist.
-
-Solltest Du die Befehlszeile zwischenzeitlich geschlossen haben, vergiss nicht wieder in das richtige Verzeichnis zu navigieren, benutze dazu den Befehl `cd qmk_firmware`.
-
-## Navigiere in deinen Keymap Ordner
-
-Beginne damit, in das `keymaps` Verzeichnis für deine Tastatur zu navigieren.
-
-Wenn Du macOS oder Windows benutzt, kannst Du einfach in das keymaps Verzeichnis wechseln.
-
-?> macOS:<br>
-    open keyboards/<keyboard_folder>/keymaps
-
-?> Windows:<br>
-    start .\\keyboards\\<keyboard_folder>\\keymaps
-
-## Eine Kopie der `default`  Tastaturbelegung erstellen
-
-Wenn Du den `keymaps` Ordner geöffnet hast, solltest Du zuerst eine Kopie des `default` Verzeichnisses erstellen. Wir empfehlen dafür deinen GitHub Benutzernamen zu verweden, aber Du kannst auch jeden anderen Namen verwenden solange er nur aus Kleinbuchstaben, Zahlen und Unterstrichen besteht.
-
-Um den Prozess zu automatisieren kannst Du dazu auch das Skript `new_keymap.sh` verwenden.
-
-Navigiere dazu in das `qmk_firmware/util` Verzeichnis und gib folgenden Befehl ein:
-
-```
-./new_keymap.sh <keyboard path> <username>
-```
-
-Um zum Beispiel den Benutzernamen John für die Tastaturbelegung eines 1up60hse zu verwenden, würdest Du Folgendes eingeben:
-
-```
-./new_keymap.sh 1upkeyboards/1up60hse john
-```
-
-## Öffne `keymap.c` in deinem bevorzugtem Text Editor
-
-Öffne deine `keymap.c`. In dieser Datei findest Du die Strukturen, die das Verhalten deiner Tastatur bestimmen. Oben in der `keymap.c` befinden sich Definitionen (defines) und Aufzählungen (enums), die die Tastaturbelegung leserlicher machen sollen. Weiter unten wirst Du eine Zeile finden, die wie folgt aussieht:
-
-    const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-
-Diese Zeile markiert den Anfang der Liste der Ebenen (Layers). Darunter befinden sich Zeilen die entweder `LAYOUT` oder `KEYMAP` enthalten, das deutet auf den Start einer Ebene hin. Danach folgt eine Liste von Tasten, die dieser Ebene zugewiesen sind.
-
-!> Beim Bearbeiten einer Tastaturbelegung solltest Du darauf achten, keine Kommata hinzuzufügen oder zu entfernen. Ansonsten kann dies dazu führen, dass deine Firmware nicht mehr kompiliert und es ist nicht immer einfach festzustellen, wo genau ein Komma zuviel oder zu wenig ist. Die letzte Zeile hat am Ende kein Komma, die Zeilen davor jedoch schon.
-
-## Personalisiere die Tastaturbelegung nach deinen Wünschen
-
-Wie Du diesen Schritt abschließt ist vollkommen Dir überlassen. Ändere die eine Sache die Dich stört oder verändere alles von Grund auf. Du kannst Ebenen entfernen die Du nicht brauchst oder Neue hinzufügen, bis zu 32 Stück. Die folgende Dokumentation verrät Dir was Du hier alles definieren kannst: 
-
-* [Keycodes](de/keycodes.md)
-* [Features](de/features.md)
-* [FAQ](de/faq.md)
-
-?> Während Du langsam ein Gefühl dafür kriegst wie Keymaps funktionieren, solltest Du darauf achten nicht zuviel auf einmal zu verändern. Größere Änderungen machen es schwieriger, Probleme zu debuggen.
-
-## Deine Firmware erzeugen
-
-Wenn Du damit fertig bist, deine Tastaturbelegung anzupassen, musst Du noch die Firmware erzeugen. Öffne dazu wieder die Befehlszeile und führe folgenden Befehl aus:
-
-    make <my_keyboard>:<my_keymap>
-
-Wenn deine Tastaturbelegung z.B. "xyverz" heißt und Du die Belegung für ein rev5 planck erzeugen möchtest, lautet der Befehl:
-
-    make planck/rev5:xyverz
-
-Während des Kompiliervorgangs wird viel Text auf dem Bildschirm ausgegeben. Es sollte am Ende mit etwas enden das ungefähr so aussieht:
-
-```
-Linking: .build/planck_rev5_xyverz.elf                                                              [OK]
-Creating load file for flashing: .build/planck_rev5_xyverz.hex                                      [OK]
-Copying planck_rev5_xyverz.hex to qmk_firmware folder                                               [OK]
-Checking file size of planck_rev5_xyverz.hex                                                        [OK]
- * File size is fine - 18392/28672
-```
-
-## Deine Firmware flashen
-Bitte fahre mit [Firmware flashen](de/newbs_flashing.md) fort, um zu erfahren, wie Du deine neue Firmware auf deine Tastatur flashen kannst.

docs/de/newbs_getting_started.md

@@ -1,101 +0,0 @@
-# Einleitung
-Genau wie in einem Computer befindet sich auch in einer Tastatur ein Prozessor.
-
-Dieser Prozessor führt Software aus, die registriert wenn Tasten gedrückt bzw. wieder losgelassen werden und leitet die entsprechenden Signale an den Computer weiter.
-
-QMK übernimmt die Rolle dieser Software und teilt dem Host-Computer den aktuellen Zustand der Tastatur mit. Wenn Du eine Tastaturbelegung definierst, ist dies äquivalent zu einem ausführbarem Programm, das auf deiner Tastatur läuft.
-
-QMK möchte seine BenutzerInnen in die Lage versetzen, simple Aufgaben möglichst einfach zu gestalten und gleichzeitig komplexe Dinge zu ermöglichen, die mit normalen Tastaturen ohne zusätzliche Software undenkbar wären. Du musst nicht programmieren können, um abgefahrene Tastaturbelegungen zu gestalten - es reicht wenn Du eine Idee hast und ein paar einfache syntaktische Regeln verstehen kannst.
-
-# Los geht's!
-Bevor Du damit loslegen kannst, deine Tastaturbelegung zu erstellen, musst Du ein wenig Software installieren und Dir eine Entwicklungsumgebung aufsetzen. Die gute Nachricht ist, dass das nur einmal erledigt werden muss, egal für wie viele verschiedene Tastaturen Du hinterher Firmware entwickeln willst.
-
-Wenn Du es vorziehst mit einer grafischen Oberfläche zu entwickeln kannst Du auch dazu gerne direkt mit dem online [QMK Konfigurator](https://config.qmk.fm) loslegen. Siehe auch: [Firmware mit der Online GUI erzeugen](de/newbs_building_firmware_configurator.md)
-
-## Software herunterladen
-
-### Text Editor
-
-Du wirst ein Programm benötigen, mit dem Du **plain text** (= reiner Text) Dateien bearbeiten und speichern kannst. Wenn Du Windows benutzt, reicht dafür schon das normale `Notepad` und für Linux z.B. `gedit` oder `leafpad`. Beide sind sehr rudimentäre Editoren deren Funktionsumfang aber vollkommen ausreicht. Für macOS' standard `TextEdit` muss man ein bisschen vorsichtig sein und darauf achten, beim Speichern explizit unter _Format_ die Option _Reiner Text_ auszuwählen.
-
-Ansonsten ist es empfehlenswert, einen Editor herunterzuladen der für die Programmierung und das Bearbeiten von Code ausgelegt ist wie z.b [Notepad++](http://notepad-plus-plus.org/), [Sublime Text](https://www.sublimetext.com/) oder [VS Code](https://code.visualstudio.com/).
-
-?> Immer noch unsicher, welcher Text Editor der Richtige für Dich ist? Laurence Bradford hat eine hervorragende [Einleitung](https://learntocodewith.me/programming/basics/text-editors/) zu dem Thema geschrieben (auf Englisch).
-
-### QMK Toolbox
-
-QMK Toolbox ist ein optionales grafisches Programm für Windows und macOS, das es erleichtern soll, deine Tastatur zu programmieren und zu debuggen. Du wirst es höchstwahrscheinlich früher oder später als unverzichtbar ansehen, wenn es darum geht eine Tastatur einfach zu flashen oder zu debuggen, da es ermöglicht, sich debug-Nachrichten direkt anzeigen zu lassen.
-
-[Hier kannst Du die aktuelle Version herunterladen.](https://github.com/qmk/qmk_toolbox/releases/latest)
-
-* Für Windows: `qmk_toolbox.exe` (portable) oder `qmk_toolbox_install.exe` (installer)
-* Für macOS: `QMK.Toolbox.app.zip` (portable) oder `QMK.Toolbox.pkg` (installer)
-
-## Die Entwicklungsumgebung aufsetzen
-
-
-Wir haben versucht, die Installation der Entwicklungsumgebung für QMK so einfach wie möglich zu gestalten. Alles, was Du tun musst, ist eine Linux oder Unix Umgebung aufzusetzen, danach macht QMK den Rest.
-
-?> Wenn Du das erste Mal mit der Linux/Unix Befehlszeile arbeitest, schadet es nicht, sich mit ein paar Grundlagen und Befehlen vertraut zu machen. Diese Ressourcen sollten ausreichen, um sich das Nötigste anzueignen um mit QMK arbeiten zu können:<br>
-[Erforderliche Linux Grundlagen](https://www.guru99.com/must-know-linux-commands.html)<br>
-[Noch ein paar Linux Befehle](https://www.tjhsst.edu/~dhyatt/superap/unixcmd.html)
-
-### Windows
-
-Du wirst MSYS2 (o.Ä.) und Git benötigen.
-
-* Befolge die Installationsanleitung auf der [MSYS2 Homepage](http://www.msys2.org)
-* Schließe alle offenen MSYS2 Fenster und öffne ein neues MSYS2 MinGW 64-bit Terminal
-* Installiere Git mit dem Kommando: `pacman -S git`
-
-### macOS
-
-Du wirst Homebrew benötigen. Folge dafür den Anweisungen auf der [Homebrew homepage](https://brew.sh).
-
-Nachdem Homebrew erfolgreich installiert ist, kannst Du mit _QMK aufsetzen_ fortfahren. 
-
-### Linux
-
-Du benötigst Git, aber es ist ziemlich wahrscheinlich, dass es bereits installiert ist. Sollte dies nicht der Fall sein, kannst Du es mit dem folgenden Aufruf installieren:
-
-* Debian / Ubuntu / Devuan: `apt-get install git`
-* Fedora / Red Hat / CentOS: `yum install git`
-* Arch Linux: `pacman -S git`
-
-?> Docker ist ebenfalls eine Option für alle Plattformen. [Hier](de/getting_started_build_tools.md#docker) kannst Du dazu weitere Informationen finden.
-
-## QMK aufsetzen
-Wenn Du damit fertig bist, deine Linux/Unix Umgebung zu installieren, kannst Du damit fortfahren QMK herunterzuladen. Dafür werden wir mit Git das QMK Repository "klonen". Öffne ein Terminal oder ein MSYS2 MinGW Fenster, dies wirst Du für den Rest der Anleitung benötigen. In diesem Fenster rufst Du nun die beiden folgenden Kommandos auf:
-
-```shell
-git clone --recurse-submodules https://github.com/qmk/qmk_firmware.git
-cd qmk_firmware
-```
-?> Wenn Du bereits weißt, [wie man GitHub benutzt](de/getting_started_github.md), empfehlen wir, dass Du Dir ein eigenen Fork erstellst. Wenn Du nicht weißt, was das bedeuten soll, kannst Du diesen Ratschlag getrost ignorieren.
-
-QMK liefert ein Script mit, das helfen soll, Dir alles Weitere abzunehmen. Du kannst es mit dem folgenden Befehl aufrufen:
-
-    util/qmk_install.sh
-
-## Die Build-Umgebung testen
-
-Nun sollte hoffentlich alles Nötige für eine funktionierende QMK Build-Umgebung installiert sein und Du solltest in der Lage sein, die QMK-Firmware zu kompilieren. Um dies mit einer `default` Tastaturbelegung zu testen, kannst Du den folgenden Befehl ausprobieren:
-
-    make <keyboard>:default
-
-Der Befehl um z.B. die Firmware für ein _Clueboard 66%_ zu erzeugen lautet:
-
-    make clueboard/66/rev3:default
-
-Wenn es fertig ist, sollte der Output ungefähr so ähnlich wie das Folgende aussehen:
-
-```
-Linking: .build/clueboard_66_rev3_default.elf                                                       [OK]
-Creating load file for flashing: .build/clueboard_66_rev3_default.hex                               [OK]
-Copying clueboard_66_rev3_default.hex to qmk_firmware folder                                        [OK]
-Checking file size of clueboard_66_rev3_default.hex                                                 [OK]
- * The firmware size is fine - 26356/28672 (2316 bytes free)
-```
-
-# Eine eigene Tastaturbelegung erstellen
-Du bist nun fertig mit dem Setup der Entwicklungsumgebung und solltest somit in der Lage sein, deine eigenen Tastaturbelegungen zu erstellen. Um fortzufahren, folge bitte der nächsten Anleitung unter [Die erste Firmware](de/newbs_building_firmware.md).

docs/de/newbs_learn_more_resources.md

@@ -1,14 +0,0 @@
-# Lernmaterial
-
-Diese weiterführenden Ressourcen sind darauf ausgerichtet, Neulingen der QMK Commmunity mehr Informationen und ein besseres Verständnis zu einzelnen Themen zu bieten.
-
-Git Ressourcen:
-
-* [Gutes allgemeines Tutorial](https://www.codecademy.com/learn/learn-git) (auf Englisch)
-* [Git spielerisch anhand von Beispielen lernen](https://learngitbranching.js.org/) (auf Englisch)
-* [Mehr über den allgemeinen Umgang mit Github](getting_started_github.md)
-* [Mehr über Git im Bezug zu QMK](contributing.md)
-
-Mehr über die Arbeit mit der Befehlszeile:
-
-* [Gutes allgemeines Tutorial über die Arbeit mit der Befehlszeile](https://www.codecademy.com/learn/learn-the-command-line) (auf Englisch)

docs/de/newbs_testing_debugging.md

@@ -1,100 +0,0 @@
-# Testen und Debuggen
-
-Nachdem Du deine Tastatur mit deiner angepassten Firmware geflasht hast, ist es nun an der Zeit sie auszuprobieren. Mit ein bisschen Glück sollte alles ohne Probleme funktionieren, wenn dies nicht der Fall ist, soll dieses Dokument dir dabei helfen, herauszufinden wo das Problem liegt.
-
-## Testen
-
-Die Tastatur zu testen ist relativ selbsterklärend. Drücke jede der Tasten um dich zu versichern, dass der gesendete Keyode der ist, den du erwarten würdest. Dafür gibt es sogar ein paar Programme die helfen sollen, dass keine Taste ausgelassen wurde.
-
-Anmerkung: Diese Programme werden weder von QMK bereitgestellt oder gutgeheißen.
-
-* [Switch Hitter](https://elitekeyboards.com/switchhitter.php) (Nur für Windows)
-* [Keyboard Viewer](https://www.imore.com/how-use-keyboard-viewer-your-mac) (Nur für Mac)
-* [Keyboard Tester](http://www.keyboardtester.com) (Web basiert)
-* [Keyboard Checker](http://keyboardchecker.com) (Web basiert)
-
-## Debuggen
-
-Deine Tastatur wird Debug Informationen liefern wenn Du `CONSOLE_ENABLE = yes` in deiner `rules.mk` gesetzt hast. Die default-Ausgabe ist sehr beschränkt und kann wenn nötig durch die Aktivierung des Debug-Modes erhöht werden. Benutze dafür entweder den `DEBUG` Keycode in deiner Tastaturbelegung, das [Command](de/feature_command.md)-Feature oder füge den folgenden Code zu deiner Tastaturbelegung hinzu.
-
-```c
-void keyboard_post_init_user(void) {
-  // Customise these values to desired behaviour
-  debug_enable=true;
-  debug_matrix=true;
-  //debug_keyboard=true;
-  //debug_mouse=true;
-}
-```
-
-### Debuggen mit der QMK Toolbox
-
-Für kompatible Plattformen kann die [QMK Toolbox](https://github.com/qmk/qmk_toolbox) benutzt werden um Debug-Nachrichten deiner Tastatur anzuzeigen.
-
-### Debuggen mit hid_listen
-
-Bevorzugst Du es lieber auf der Befehlszeile zu debuggen? Dafür eignet sich das Programm [hid_listen](https://www.pjrc.com/teensy/hid_listen.html) von PJRC. Binaries sind für Windows, Linux und MacOS verfügbar.
-
-<!-- FIXME: Describe the debugging messages here. -->
-
-## Eigene Debug-Nachrichten senden
-
-Manchmal ist es hilfreich Debug-Nachrichten innerhalb deines eigenen [Custom Codes](de/custom_quantum_functions.md) zu drucken. Das ist ziemlich einfach. Beginne damit `print.h` am Anfang deiner Datei zu inkludieren:
-
-    #include <print.h>
-
-Danach stehen dir verschiedene Druck-Funktionen zur Verfügung:
-
-* `print("string")`: Druckt einen simplen String
-* `uprintf("%s string", var)`: Druckt einen formatierten String
-* `dprint("string")` Druckt einen simplen String, aber nur wenn der Debug-Mode aktiviert ist
-* `dprintf("%s string", var)`: Druckt einen formatierten String, aber nur wenn der Debug-Mode aktiviert ist
-
-## Debug Beispiele
-
-Anbei findest Du eine Sammlung von hilfreichen Beispielen. Für weitere Informationen Informationen sei an dieser Stelle auf [Debugging/Troubleshooting QMK](de/faq_debug.md) verwiesen.
-
-### Which matrix position is this keypress?
-### Welche Matrix Position hat dieser Tastenanschlag
-
-Beim Portieren, oder bei der Fehlerdiagnose von PCB Problemen, ist es nützlich sich anzeigen zu lassen ob ein Tastenanschlag richtig erkannt wurde. Um die Protokollierung für diesen Fall zu aktivieren, füge bitte folgenden Code zu deiner Tastaturbelegung `keymap.c` hinzu.
-
-```c
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-  // Wenn 'console' aktiviert ist wird die Matrix-Position und der Status jedes Tastenanschlags ausgegeben 
-#ifdef CONSOLE_ENABLE
-    uprintf("KL: kc: %u, col: %u, row: %u, pressed: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed);
-#endif 
-  return true;
-}
-```
-
-Beispiel Ausgabe:
-```text
-Waiting for device:.......
-Listening:
-KL: kc: 169, col: 0, row: 0, pressed: 1
-KL: kc: 169, col: 0, row: 0, pressed: 0
-KL: kc: 174, col: 1, row: 0, pressed: 1
-KL: kc: 174, col: 1, row: 0, pressed: 0
-KL: kc: 172, col: 2, row: 0, pressed: 1
-KL: kc: 172, col: 2, row: 0, pressed: 0
-```
-
-### Wieviel Zeit wurde benötigt um einen Tastenanschlag zu detektieren?
-
-Wenn Performance-Probleme auftreten ist es hilfreich die Frequenz, mit der die Matrix gescannt wird, zu wissen. Um dies in diesem Fall zu aktiveren füge, den folgenden Code zu deiner Tastaturbelegung in `config.h` hinzu.
-
-```c
-#define DEBUG_MATRIX_SCAN_RATE
-```
-
-Beispiel Ausgabe
-```text
-  > matrix scan frequency: 315
-  > matrix scan frequency: 313
-  > matrix scan frequency: 316
-  > matrix scan frequency: 316
-  > matrix scan frequency: 316
-  > matrix scan frequency: 316
-```

docs/documentation_templates.md

@@ -28,9 +28,9 @@ the Ctrl, Alt, or GUI modifiers are held down.
 
 A compact 40% (12x4) ortholinear keyboard kit made and sold by OLKB and Massdrop. [More info on qmk.fm](http://qmk.fm/planck/)
 
-* Keyboard Maintainer: [Jack Humbert](https://github.com/jackhumbert)
-* Hardware Supported: Planck PCB rev1, rev2, rev3, rev4, Teensy 2.0
-* Hardware Availability: [OLKB.com](https://olkb.com), [Massdrop](https://www.massdrop.com/buy/planck-mechanical-keyboard?mode=guest_open)
+Keyboard Maintainer: [Jack Humbert](https://github.com/jackhumbert)  
+Hardware Supported: Planck PCB rev1, rev2, rev3, rev4, Teensy 2.0  
+Hardware Availability: [OLKB.com](https://olkb.com), [Massdrop](https://www.massdrop.com/buy/planck-mechanical-keyboard?mode=guest_open)
 
 Make example for this keyboard (after setting up your build environment):
 
@@ -38,3 +38,5 @@ Make example for this keyboard (after setting up your build environment):
 
 See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs).
 ```
+
+There needs to be two spaces at the end of the `Keyboard Maintainer` and `Hardware Supported` lines for it to render correctly with Markdown.

docs/es/README.md

@@ -1,32 +0,0 @@
-# Firmware Quantum Mechanical Keyboard
-
-[![Versión actual](https://img.shields.io/github/tag/qmk/qmk_firmware.svg)](https://github.com/qmk/qmk_firmware/tags)
-[![Estado de Build](https://travis-ci.org/qmk/qmk_firmware.svg?branch=master)](https://travis-ci.org/qmk/qmk_firmware)
-[![Discord](https://img.shields.io/discord/440868230475677696.svg)](https://discord.gg/Uq7gcHh)
-[![Estado de la documentación](https://img.shields.io/badge/docs-ready-orange.svg)](https://docs.qmk.fm)
-[![Contribuyentes en GitHub](https://img.shields.io/github/contributors/qmk/qmk_firmware.svg)](https://github.com/qmk/qmk_firmware/pulse/monthly)
-[![Forks en GitHub](https://img.shields.io/github/forks/qmk/qmk_firmware.svg?style=social&label=Fork)](https://github.com/qmk/qmk_firmware/)
-
-## ¿Qué es el firmware QMK?
-
-QMK (*Quantum Mechanical Keyboard*) es una comunidad open source que mantiene el firmware QMK, QMK Toolbox, qmk.fm, y estos documentos. El firmware QMK es un firmware para teclados basado en [tmk\_keyboard](http://github.com/tmk/tmk_keyboard) con algunas características útiles para controladores Atmel AVR, y más específicamente, la [línea de productos OLKB](http://olkb.com), el teclado [ErgoDox EZ](http://www.ergodox-ez.com), y la [línea de productos Clueboard](http://clueboard.co/). También ha sido portado a chips ARM chips usando ChibiOS. Lo puedes utilizar para manejar tu propio teclado ya sea cableado a mano o basado en una PCB personalizada.
-
-## Cómo conseguirlo
-
-Si estás pensando en contribuir con un keymap, teclado, or característica a QMK, la manera más sencilla es hacer un [fork del repositorio en Github](https://github.com/qmk/qmk_firmware#fork-destination-box), y clonar tu repositorio localmente para hacer los cambios, subirlos, y abir un [Pull Request](https://github.com/qmk/qmk_firmware/pulls) desde tu fork.
-
-De cualquier manera, también puedes descargarlo directamente en formatos ([zip](https://github.com/qmk/qmk_firmware/zipball/master), [tar](https://github.com/qmk/qmk_firmware/tarball/master)), o clonarlo via git (`git@github.com:qmk/qmk_firmware.git`), o https (`https://github.com/qmk/qmk_firmware.git`).
-
-## Cómo compilar
-
-Antes de poder compilar, necesitarás [instalar un entorno](getting_started_build_tools.md) para el desarrollo de AVR y/o ARM. Una vez hayas completado este paso, usarás el comando `make` para compilar un teclado y keymap con la siguiente notación:
-
-    make planck/rev4:default
-
-Este ejemplo compilaría la revisión `rev4` del teclado `planck` con el keymap `default`. No todos los teclados tienen revisiones (también llamados subproyectos o carpetas), en ese caso, se puede omitir:
-
-    make preonic:default
-
-## Cómo personalizar
-
-QMK tiene montones de [características](features.md) para explorar, y una buena cantidad de [documentación de referencia](http://docs.qmk.fm) en la que sumergirse. Se pueden sacar provecho de la mayoría de las características modificando tu [keymap](keymap.md), y cambiando los [keycodes](keycodes.md).