Branch point for 2020 Feb 29 Breaking Change.

.clang_complete

@@ -0,0 +1,24 @@
+
+-I.
+-I./drivers
+-I./drivers/avr
+-I./keyboards/ergodox_ez
+-I./keyboards/ergodox_ez/keymaps/vim
+-I./lib
+-I./lib/lufa
+-I./quantum
+-I./quantum/api
+-I./quantum/audio
+-I./quantum/keymap_extras
+-I./quantum/process_keycode
+-I./quantum/serial_link
+-I./quantum/template
+-I./quantum/tools
+-I./quantum/visualizer
+-I./tmk_core
+-I./tmk_core/common
+-I./tmk_core/common/debug.h
+-I./tmk_core/protocol
+-I./tmk_core/protocol/lufa
+-I./util
+-DQMK_KEYBOARD=\"$(KEYBOARD)\" -DQMK_KEYMAP=\"$(KEYMAP)\"

.github/workflows/cli.yml

@@ -1,28 +0,0 @@
-name: CLI CI
-
-on:
-  push:
-    branches:
-    - master
-    - future
-  pull_request:
-    paths:
-    - 'lib/python/**'
-    - 'bin/qmk'
-    - 'requirements.txt'
-    - '.github/workflows/cli.yml'
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-
-    container: qmkfm/base_container
-
-    steps:
-    - uses: actions/checkout@v2
-      with:
-        submodules: recursive
-    - name: Install dependencies
-      run: pip3 install -r requirements.txt
-    - name: Run tests
-      run: bin/qmk pytest

.gitignore

@@ -24,7 +24,6 @@ quantum/version.h
 .idea/
 CMakeLists.txt
 cmake-build-debug
-.clang_complete
 doxygen/
 .DS_Store
 /util/wsl_downloaded
@@ -48,6 +47,7 @@ doxygen/
 *.iml
 .browse.VC.db*
 *.stackdump
+util/Win_Check_Output.txt
 # Let these ones be user specific, since we have so many different configurations
 .vscode/c_cpp_properties.json
 .vscode/launch.json
@@ -63,6 +63,9 @@ doxygen/
 *.gif
 *.jpg
 
+# Do not ignore MiniDox left/right hand eeprom files
+!keyboards/minidox/*.eep
+
 # things travis sees
 secrets.tar
 id_rsa_*
@@ -70,6 +73,3 @@ id_rsa_*
 
 # python things
 __pycache__
-
-# prerequisites for updating ChibiOS
-/util/fmpp*

.gitmodules

@@ -1,15 +1,13 @@
 [submodule "lib/chibios"]
 	path = lib/chibios
 	url = https://github.com/qmk/ChibiOS
-	branch = master
 [submodule "lib/chibios-contrib"]
 	path = lib/chibios-contrib
 	url = https://github.com/qmk/ChibiOS-Contrib
-	branch = master
+	branch = k-type-fix
 [submodule "lib/ugfx"]
 	path = lib/ugfx
 	url = https://github.com/qmk/uGFX
-	branch = master
 [submodule "lib/googletest"]
 	path = lib/googletest
 	url = https://github.com/google/googletest

.travis.yml

@@ -12,18 +12,6 @@ env:
   - MAKEFLAGS="-j3 --output-sync"
 services:
   - docker
-addons:
-  apt:
-    sources:
-      - ubuntu-toolchain-r-test
-      - llvm-toolchain-trusty-7
-    packages:
-    - pandoc
-    - diffutils
-    - dos2unix
-    - doxygen
-    - clang-format-7
-    - libstdc++-7-dev
 install:
   - npm install -g moxygen
 script:
@@ -32,6 +20,13 @@ script:
   - bash util/travis_test.sh
   - bash util/travis_build.sh
   - bash util/travis_docs.sh
+addons:
+  apt:
+    packages:
+    - pandoc
+    - diffutils
+    - dos2unix
+    - doxygen
 after_script:
   bash util/travis_compiled_push.sh
 notifications:

.vscode/settings.json

@@ -5,21 +5,15 @@
     // Configure glob patterns for excluding files and folders.
     "files.exclude": {
         "**/.build": true,
-        "**/*.hex": true,
-        "**/*.bin": true
+        "**/*.hex": true
     },
     "files.associations": {
-        "*.h": "c",
-        "*.c": "c",
-        "*.inc": "c",
-        "*.cpp": "cpp",
-        "*.hpp": "cpp",
-        "xstddef": "c",
-        "type_traits": "c",
-        "utility": "c"
-    },
-    "[markdown]": {
-        "editor.trimAutoWhitespace": false,
-        "files.trimTrailingWhitespace": false
+      "*.h": "c",
+      "*.c": "c",
+      "*.cpp": "cpp",
+      "*.hpp": "cpp",
+      "xstddef": "c",
+      "type_traits": "c",
+      "utility": "c"
     }
 }

Makefile

@@ -623,19 +623,13 @@ endif
 # Generate the version.h file
 ifndef SKIP_GIT
     GIT_VERSION := $(shell git describe --abbrev=6 --dirty --always --tags 2>/dev/null || date +"%Y-%m-%d-%H:%M:%S")
-    CHIBIOS_VERSION := $(shell cd lib/chibios && git describe --abbrev=6 --dirty --always --tags 2>/dev/null || date +"%Y-%m-%d-%H:%M:%S")
-    CHIBIOS_CONTRIB_VERSION := $(shell cd lib/chibios-contrib && git describe --abbrev=6 --dirty --always --tags 2>/dev/null || date +"%Y-%m-%d-%H:%M:%S")
 else
     GIT_VERSION := NA
-    CHIBIOS_VERSION := NA
-    CHIBIOS_CONTRIB_VERSION := NA
 endif
 ifndef SKIP_VERSION
 BUILD_DATE := $(shell date +"%Y-%m-%d-%H:%M:%S")
 $(shell echo '#define QMK_VERSION "$(GIT_VERSION)"' > $(ROOT_DIR)/quantum/version.h)
 $(shell echo '#define QMK_BUILDDATE "$(BUILD_DATE)"' >> $(ROOT_DIR)/quantum/version.h)
-$(shell echo '#define CHIBIOS_VERSION "$(CHIBIOS_VERSION)"' >> $(ROOT_DIR)/quantum/version.h)
-$(shell echo '#define CHIBIOS_CONTRIB_VERSION "$(CHIBIOS_CONTRIB_VERSION)"' >> $(ROOT_DIR)/quantum/version.h)
 else
 BUILD_DATE := NA
 endif

bin/qmk

@@ -2,61 +2,52 @@
 """CLI wrapper for running QMK commands.
 """
 import os
+import subprocess
 import sys
 from importlib.util import find_spec
-from pathlib import Path
+from time import strftime
 
 # Add the QMK python libs to our path
-script_dir = Path(os.path.realpath(__file__)).parent
-qmk_dir = script_dir.parent
-python_lib_dir = Path(qmk_dir / 'lib' / 'python').resolve()
-sys.path.append(str(python_lib_dir))
+script_dir = os.path.dirname(os.path.realpath(__file__))
+qmk_dir = os.path.abspath(os.path.join(script_dir, '..'))
+python_lib_dir = os.path.abspath(os.path.join(qmk_dir, 'lib', 'python'))
+sys.path.append(python_lib_dir)
 
-
-def _check_modules(requirements):
-    """ Check if the modules in the given requirements.txt are available.
-    """
-    with Path(qmk_dir / requirements).open() as fd:
-        for line in fd.readlines():
-            line = line.strip().replace('<', '=').replace('>', '=')
-
-            if len(line) == 0 or line[0] == '#' or line.startswith('-r'):
-                continue
-
-            if '#' in line:
-                line = line.split('#')[0]
-
-            module = dict()
-            module['name'] = module['import'] = line.split('=')[0] if '=' in line else line
-
-            # Not every module is importable by its own name.
-            if module['name'] == "pep8-naming":
-                module['import'] = "pep8ext_naming"
-
-            if not find_spec(module['import']):
-                print('Could not find module %s!' % module['name'])
-                print('Please run `python3 -m pip install -r %s` to install required python dependencies.' % (qmk_dir / requirements,))
-                if developer:
-                    print('You can also turn off developer mode: qmk config user.developer=None')
-                print()
-                exit(255)
-
-
-developer = False
 # Make sure our modules have been setup
-_check_modules('requirements.txt')
+with open(os.path.join(qmk_dir, 'requirements.txt'), 'r') as fd:
+    for line in fd.readlines():
+        line = line.strip().replace('<', '=').replace('>', '=')
+
+        if line[0] == '#':
+            continue
+
+        if '#' in line:
+            line = line.split('#')[0]
+
+        module = line.split('=')[0] if '=' in line else line
+
+        if module in ['pep8-naming']:
+            # Not every module is importable by its own name.
+            continue
+
+        if not find_spec(module):
+            print('Could not find module %s!' % module)
+            print('Please run `pip3 install -r requirements.txt` to install the python dependencies.')
+            exit(255)
+
+# Figure out our version
+# TODO(skullydazed/anyone): Find a method that doesn't involve git. This is slow in docker and on windows.
+command = ['git', 'describe', '--abbrev=6', '--dirty', '--always', '--tags']
+result = subprocess.run(command, universal_newlines=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+
+if result.returncode == 0:
+    os.environ['QMK_VERSION'] = result.stdout.strip()
+else:
+    os.environ['QMK_VERSION'] = 'nogit-' + strftime('%Y-%m-%d-%H:%M:%S') + '-dirty'
 
 # Setup the CLI
 import milc  # noqa
 
-# For developers additional modules are needed
-if milc.cli.config.user.developer:
-    # Do not run the check for 'config',
-    # so users can turn off developer mode
-    if len(sys.argv) == 1 or (len(sys.argv) > 1 and 'config' != sys.argv[1]):
-        developer = True
-        _check_modules('requirements-dev.txt')
-
 milc.EMOJI_LOGLEVELS['INFO'] = '{fg_blue}Ψ{style_reset_all}'
 
 

build_json.mk

@@ -21,11 +21,6 @@ else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_1)/keymap.json)","")
     KEYMAP_PATH := $(MAIN_KEYMAP_PATH_1)
 endif
 
-# Load the keymap-level rules.mk if exists
-ifneq ("$(wildcard $(KEYMAP_PATH))", "")
-    -include $(KEYMAP_PATH)/rules.mk
-endif
-
 # Generate the keymap.c
 $(KEYBOARD_OUTPUT)/src/keymap.c: $(KEYMAP_JSON)
-	bin/qmk json2c --quiet --output $(KEYMAP_C) $(KEYMAP_JSON)
+	bin/qmk json-keymap --quiet --output $(KEYMAP_C) $(KEYMAP_JSON)

build_keyboard.mk

@@ -231,19 +231,44 @@ endif
 # We can assume a ChibiOS target When MCU_FAMILY is defined since it's
 # not used for LUFA
 ifdef MCU_FAMILY
-    PLATFORM=CHIBIOS
-    PLATFORM_KEY=chibios
     FIRMWARE_FORMAT?=bin
+    PLATFORM=CHIBIOS
 else ifdef ARM_ATSAM
     PLATFORM=ARM_ATSAM
-    PLATFORM_KEY=arm_atsam
     FIRMWARE_FORMAT=bin
 else
     PLATFORM=AVR
-    PLATFORM_KEY=avr
     FIRMWARE_FORMAT?=hex
 endif
 
+ifeq ($(PLATFORM),CHIBIOS)
+    include $(TMK_PATH)/chibios.mk
+    OPT_OS = chibios
+    ifneq ("$(wildcard $(KEYBOARD_PATH_5)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(KEYBOARD_PATH_5)/bootloader_defs.h
+     else ifneq ("$(wildcard $(KEYBOARD_PATH_5)/boards/$(BOARD)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(KEYBOARD_PATH_5)/boards/$(BOARD)/bootloader_defs.h
+    else ifneq ("$(wildcard $(KEYBOARD_PATH_4)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(KEYBOARD_PATH_4)/bootloader_defs.h
+     else ifneq ("$(wildcard $(KEYBOARD_PATH_4)/boards/$(BOARD)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(KEYBOARD_PATH_4)/boards/$(BOARD)/bootloader_defs.h
+    else ifneq ("$(wildcard $(KEYBOARD_PATH_3)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(KEYBOARD_PATH_3)/bootloader_defs.h
+     else ifneq ("$(wildcard $(KEYBOARD_PATH_3)/boards/$(BOARD)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(KEYBOARD_PATH_3)/boards/$(BOARD)/bootloader_defs.h
+    else ifneq ("$(wildcard $(KEYBOARD_PATH_2)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(KEYBOARD_PATH_2)/bootloader_defs.h
+     else ifneq ("$(wildcard $(KEYBOARD_PATH_2)/boards/$(BOARD)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(KEYBOARD_PATH_2)/boards/$(BOARD)/bootloader_defs.h
+    else ifneq ("$(wildcard $(KEYBOARD_PATH_1)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(KEYBOARD_PATH_1)/bootloader_defs.h
+     else ifneq ("$(wildcard $(KEYBOARD_PATH_1)/boards/$(BOARD)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(KEYBOARD_PATH_1)/boards/$(BOARD)/bootloader_defs.h
+    else ifneq ("$(wildcard $(TOP_DIR)/drivers/boards/$(BOARD)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(TOP_DIR)/drivers/boards/$(BOARD)/bootloader_defs.h
+    endif
+endif
+
 # Find all of the config.h files and add them to our CONFIG_H define.
 CONFIG_H :=
 ifneq ("$(wildcard $(KEYBOARD_PATH_5)/config.h)","")
@@ -279,6 +304,11 @@ ifneq ("$(wildcard $(KEYBOARD_PATH_5)/post_config.h)","")
     POST_CONFIG_H += $(KEYBOARD_PATH_5)/post_config.h
 endif
 
+# Save the defines and includes here, so we don't include any keymap specific ones
+PROJECT_DEFS := $(OPT_DEFS)
+PROJECT_INC := $(VPATH) $(EXTRAINCDIRS) $(KEYBOARD_PATHS)
+PROJECT_CONFIG := $(CONFIG_H)
+
 # Userspace setup and definitions
 ifeq ("$(USER_NAME)","")
     USER_NAME := $(KEYMAP)
@@ -324,17 +354,23 @@ SRC += $(TMK_COMMON_SRC)
 OPT_DEFS += $(TMK_COMMON_DEFS)
 EXTRALDFLAGS += $(TMK_COMMON_LDFLAGS)
 
-include $(TMK_PATH)/$(PLATFORM_KEY).mk
-ifneq ($(strip $(PROTOCOL)),)
-    include $(TMK_PATH)/protocol/$(strip $(shell echo $(PROTOCOL) | tr '[:upper:]' '[:lower:]')).mk
+ifeq ($(PLATFORM),AVR)
+ifeq ($(strip $(PROTOCOL)), VUSB)
+    include $(TMK_PATH)/protocol/vusb.mk
 else
-    include $(TMK_PATH)/protocol/$(PLATFORM_KEY).mk
+    include $(TMK_PATH)/protocol/lufa.mk
+endif
+    include $(TMK_PATH)/avr.mk
 endif
 
-# TODO: remove this bodge?
-PROJECT_DEFS := $(OPT_DEFS)
-PROJECT_INC := $(VPATH) $(EXTRAINCDIRS) $(KEYBOARD_PATHS)
-PROJECT_CONFIG := $(CONFIG_H)
+ifeq ($(PLATFORM),ARM_ATSAM)
+    include $(TMK_PATH)/arm_atsam.mk
+    include $(TMK_PATH)/protocol/arm_atsam.mk
+endif
+
+ifeq ($(PLATFORM),CHIBIOS)
+    include $(TMK_PATH)/protocol/chibios.mk
+endif
 
 ifeq ($(strip $(VISUALIZER_ENABLE)), yes)
     VISUALIZER_DIR = $(QUANTUM_DIR)/visualizer

build_test.mk

@@ -41,7 +41,6 @@ all: elf
 
 VPATH += $(COMMON_VPATH)
 PLATFORM:=TEST
-PLATFORM_KEY:=test
 
 ifneq ($(filter $(FULL_TESTS),$(TEST)),)
 include tests/$(TEST)/rules.mk

docs/ChangeLog/20200229.md

@@ -1,75 +0,0 @@
-# QMK Breaking Change - 2020 Feb 29 Changelog
-
-Four times a year QMK runs a process for merging Breaking Changes. A Breaking Change is any change which modifies how QMK behaves in a way that is incompatible or potentially dangerous. We limit these changes to 4 times per year so that users can have confidence that updating their QMK tree will not break their keymaps.
-
-
-## Update ChibiOS/ChibiOS-Contrib/uGFX submodules
-
-* General Notes
-    * A `make git-submodule` may be required after pulling the latest QMK firmware code to update affected submodules to the upgraded revisions
-    * Enabling link-time-optimization (`LINK_TIME_OPTIMIZATION_ENABLE = yes`) should work on a lot more boards
-* Upgrade to ChibiOS ver19.1.3
-    * This will allow QMK to update to upstream ChibiOS a lot easier -- the old version was ~2 years out of date. Automated update scripts have been made available to simplify future upgrades.
-    * Includes improved MCU support and bugfixes
-    * ChibiOS revision is now included in Command output
-    * Timers should now be more accurate
-* Upgrade to newer ChibiOS-Contrib
-    * Also includes improved MCU support and bugfixes
-    * ChibiOS-Contrib revision is now included in Command output
-* Upgrade to newer uGFX
-    * Required in order to support updated ChibiOS
-
-
-## Fix ChibiOS timer overflow for 16-bit SysTick devices
-
-* On 16-bit SysTick devices, the timer subsystem in QMK was incorrectly dealing with overflow.
-    * When running at a 100000 SysTick frequency (possible on 16-bit devices, but uncommon), this overflow would occur after 0.65 seconds.
-* Timers are now correctly handling this overflow case and timing should now be correct on ChibiOS/ARM.
-
-
-## Update LUFA submodule
-
-* Updates the LUFA submodule to include updates from upstream (abcminiuser/lufa)
-* Includes some cleanup for QMK DFU generation
-
-
-## Encoder flip
-
-* Flips the encoder direction so that `clockwise == true` is for actually turning the knob clockwise
-* Adds `ENCODER_DIRECTION_FLIP` define, so that reversing the expected dirction is simple for users.
-* Cleans up documentation page for encoders
-
-
-## Adding support for `BACKLIGHT_ON_STATE` for hardware PWM backlight
-
-* Previously, the define only affected software PWM, and hardware PWM always assumed an N-channel MOSFET.
-* The hardware PWM backlight setup has been updated to respect this option.
-* The default "on" state has been changed to `1` - **this impacts all keyboards using software PWM backlight that do not define it explicitly**. If your keyboard's backlight is acting strange, it may have a P-channel MOSFET, and will need to have `#define BACKLIGHT_ON_STATE 0` added to the keyboard-level `config.h`. Please see the PR for more detailed information.
-
-
-## Migrating `ACTION_LAYER_TAP_KEY()` entries in `fn_actions` to `LT()` keycodes
-
-* `fn_actions` is deprecated, and its functionality has been superseded by direct keycodes and `process_record_user()`
-* The end result of removing this obsolete feature should result in a decent reduction in firmware size and code complexity
-* All keymaps affected are recommended to switch away from `fn_actions` in favour of the [custom keycode](https://docs.qmk.fm/#/custom_quantum_functions) and [macro](https://docs.qmk.fm/#/feature_macros) features
-
-
-## Moving backlight keycode handling to `process_keycode/`
-
-* This refactors the backlight keycode logic to be clearer and more modular.
-* All backlight-related keycodes are now actioned in a single file.
-* The `ACTION_BACKLIGHT_*` macros have also been deleted. If you are still using these in a `fn_actions[]` block, please switch to using the backlight keycodes or functions directly.
-
-
-## Refactor Planck keymaps to use Layout Macros
-
-* Refactor Planck keymaps to use layout macros instead of raw matrix assignments
-* Makes keymaps revision-agnostic
-* Should reduce noise and errors in Travis CI logs
-
-
-## GON NerD codebase refactor
-
-* Splits the codebase for GON NerD 60 and NerdD TKL PCBs into two separate directories.
-* If your keymap is for a NerD 60 PCB, your `make` command is now `make gon/nerd60:<keymap>`.
-* If your keymap is for a NerD TKL PCB, your `make` command is now `make gon/nerdtkl:<keymap>`.

docs/README.md

@@ -9,35 +9,24 @@
 
 ## What is QMK Firmware?
 
-QMK (*Quantum Mechanical Keyboard*) is an open source community centered around developing computer input devices. The community encompasses all sorts of input devices, such as keyboards, mice, and MIDI devices. A core group of collaborators maintains [QMK Firmware](https://github.com/qmk/qmk_firmware), [QMK Configurator](https://config.qmk.fm), [QMK Toolbox](https://github.com/qmk/qmk_toolbox), [qmk.fm](https://qmk.fm), and this documentation with the help of community members like you.
+QMK (*Quantum Mechanical Keyboard*) is an open source community that maintains QMK Firmware, QMK Toolbox, qmk.fm, and these docs. QMK Firmware is a keyboard firmware based on the [tmk\_keyboard](http://github.com/tmk/tmk_keyboard) with some useful features for Atmel AVR controllers, and more specifically, the [OLKB product line](http://olkb.com), the [ErgoDox EZ](http://www.ergodox-ez.com) keyboard, and the [Clueboard product line](http://clueboard.co/). It has also been ported to ARM chips using ChibiOS. You can use it to power your own hand-wired or custom keyboard PCB.
 
-## Get Started
+## How to Get It
 
-Totally new to QMK? There are two ways to get started:
+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.
 
-* Basic: [QMK Configurator](https://config.qmk.fm)
-    * Just select your keyboard from the dropdown and program your keyboard.
-    * We have an [introductory video](https://www.youtube.com/watch?v=-imgglzDMdY) you can watch.
-    * There is also an overview [document you can read](newbs_building_firmware_configurator.md).
-* Advanced: [Use The Source](newbs.md)
-    * More powerful, but harder to use
+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.
 
-## Make It Yours
+## How to Compile
 
-QMK has lots of [features](features.md) to explore, and a good deal of reference documentation to dig through. Most features are taken advantage of by modifying your [keymap](keymap.md), and changing the [keycodes](keycodes.md).
+Before you are able to compile, you'll need to [install an environment](getting_started_build_tools.md) for AVR or/and ARM development. Once that is complete, you'll use the `make` command to build a keyboard and keymap with the following notation:
 
-## Need help?
+    make planck/rev4:default
 
-Check out the [support page](support.md) to see how you can get help using QMK.
+This would build the `rev4` revision of the `planck` with the `default` keymap. Not all keyboards have revisions (also called subprojects or folders), in which case, it can be omitted:
 
-## Give Back
+    make preonic:default
 
-There are a lot of ways you can contribute to the QMK Community. The easiest way to get started is to use it and spread the word to your friends.
+## How to Customize
 
-* Help people out on our forums and chat rooms:
-    * [/r/olkb](https://www.reddit.com/r/olkb/)
-    * [Discord Server](https://discord.gg/Uq7gcHh)
-* Contribute to our documentation by clicking "Edit This Page" at the bottom
-* [Translate our documentation into your language](translating.md)
-* [Report a bug](https://github.com/qmk/qmk_firmware/issues/new/choose)
-* [Open a Pull Request](contributing.md)
+QMK has lots of [features](features.md) to explore, and a good deal of [reference documentation](http://docs.qmk.fm) to dig through. Most features are taken advantage of by modifying your [keymap](keymap.md), and changing the [keycodes](keycodes.md).

docs/_summary.md

@@ -1,169 +1,127 @@
-* Tutorial
-  * [Introduction](newbs.md)
-  * [Setup](newbs_getting_started.md)
+* [Complete Newbs Guide](newbs.md)
+  * [Getting Started](newbs_getting_started.md)
   * [Building Your First Firmware](newbs_building_firmware.md)
   * [Flashing Firmware](newbs_flashing.md)
   * [Testing and Debugging](newbs_testing_debugging.md)
-  * [Getting Help/Support](support.md)
-  * [Other Resources](newbs_learn_more_resources.md)
-  * [Syllabus](syllabus.md)
+  * [Best Git Practices](newbs_git_best_practices.md)
+    * [Using Your Fork's Master](newbs_git_using_your_master_branch.md)
+    * [Resolving Merge Conflicts](newbs_git_resolving_merge_conflicts.md)
+    * [Resynchronizing a Branch](newbs_git_resynchronize_a_branch.md)
+  * [Learning Resources](newbs_learn_more_resources.md)
 
-* FAQs
+* [QMK Basics](README.md)
+  * [QMK Introduction](getting_started_introduction.md)
+  * [QMK CLI](cli.md)
+  * [QMK CLI Config](cli_configuration.md)
+  * [Contributing to QMK](contributing.md)
+  * [How to Use Github](getting_started_github.md)
+  * [Getting Help](getting_started_getting_help.md)
+
+* [Breaking Changes](breaking_changes.md)
+  * [2019 Aug 30](ChangeLog/20190830.md)
+
+* [FAQ](faq.md)
   * [General FAQ](faq_general.md)
   * [Build/Compile QMK](faq_build.md)
   * [Debugging/Troubleshooting QMK](faq_debug.md)
-  * [Keymap FAQ](faq_keymap.md)
+  * [Keymap](faq_keymap.md)
+  * [Driver Installation with Zadig](driver_installation_zadig.md)
+
+* Detailed Guides
+  * [Install Build Tools](getting_started_build_tools.md)
+  * [Vagrant Guide](getting_started_vagrant.md)
+  * [Build/Compile Instructions](getting_started_make_guide.md)
+  * [Flashing Firmware](flashing.md)
+  * [Customizing Functionality](custom_quantum_functions.md)
+  * [Keymap Overview](keymap.md)
+
+* [Hardware](hardware.md)
+  * [Compatible Microcontrollers](compatible_microcontrollers.md)
+  * [AVR Processors](hardware_avr.md)
+  * [Drivers](hardware_drivers.md)
+
+* Reference
+  * [Keyboard Guidelines](hardware_keyboard_guidelines.md)
+  * [Config Options](config_options.md)
+  * [Keycodes](keycodes.md)
+  * [Coding Conventions - C](coding_conventions_c.md)
+  * [Coding Conventions - Python](coding_conventions_python.md)
+  * [Documentation Best Practices](documentation_best_practices.md)
+  * [Documentation Templates](documentation_templates.md)
   * [Glossary](reference_glossary.md)
+  * [Unit Testing](unit_testing.md)
+  * [Useful Functions](ref_functions.md)
+  * [Configurator Support](reference_configurator_support.md)
+  * [info.json Format](reference_info_json.md)
+  * [Python CLI Development](cli_development.md)
 
-* Configurator
-  * [Overview](newbs_building_firmware_configurator.md)
-  * [Step by Step](configurator_step_by_step.md)
-  * [Troubleshooting](configurator_troubleshooting.md)
-  * QMK API
-    * [Overview](api_overview.md)
-    * [API Documentation](api_docs.md)
-    * [Keyboard Support](reference_configurator_support.md)
+* [Features](features.md)
+  * [Basic Keycodes](keycodes_basic.md)
+  * [US ANSI Shifted Keys](keycodes_us_ansi_shifted.md)
+  * [Quantum Keycodes](quantum_keycodes.md)
+  * [Advanced Keycodes](feature_advanced_keycodes.md)
+  * [Audio](feature_audio.md)
+  * [Auto Shift](feature_auto_shift.md)
+  * [Backlight](feature_backlight.md)
+  * [Bluetooth](feature_bluetooth.md)
+  * [Bootmagic](feature_bootmagic.md)
+  * [Combos](feature_combo.md)
+  * [Command](feature_command.md)
+  * [Debounce API](feature_debounce_type.md)
+  * [DIP Switch](feature_dip_switch.md)
+  * [Dynamic Macros](feature_dynamic_macros.md)
+  * [Encoders](feature_encoders.md)
+  * [Grave Escape](feature_grave_esc.md)
+  * [Haptic Feedback](feature_haptic_feedback.md)
+  * [HD44780 LCD Controller](feature_hd44780.md)
+  * [Key Lock](feature_key_lock.md)
+  * [Layouts](feature_layouts.md)
+  * [Leader Key](feature_leader_key.md)
+  * [LED Matrix](feature_led_matrix.md)
+  * [Macros](feature_macros.md)
+  * [Mouse Keys](feature_mouse_keys.md)
+  * [OLED Driver](feature_oled_driver.md)
+  * [One Shot Keys](feature_advanced_keycodes.md#one-shot-keys)
+  * [Pointing Device](feature_pointing_device.md)
+  * [PS/2 Mouse](feature_ps2_mouse.md)
+  * [RGB Lighting](feature_rgblight.md)
+  * [RGB Matrix](feature_rgb_matrix.md)
+  * [Space Cadet](feature_space_cadet.md)
+  * [Split Keyboard](feature_split_keyboard.md)
+  * [Stenography](feature_stenography.md)
+  * [Swap Hands](feature_swap_hands.md)
+  * [Tap Dance](feature_tap_dance.md)
+  * [Terminal](feature_terminal.md)
+  * [Thermal Printer](feature_thermal_printer.md)
+  * [Unicode](feature_unicode.md)
+  * [Userspace](feature_userspace.md)
+  * [Velocikey](feature_velocikey.md)
 
-* CLI
-    * [Overview](cli.md)
-    * [Configuration](cli_configuration.md)
-    * [Commands](cli_commands.md)
+* For Makers and Modders
+  * [Hand Wiring Guide](hand_wire.md)
+  * [ISP Flashing Guide](isp_flashing_guide.md)
+  * [ARM Debugging Guide](arm_debugging.md)
+  * [ADC Driver](adc_driver.md)
+  * [I2C Driver](i2c_driver.md)
+  * [WS2812 Driver](ws2812_driver.md)
+  * [GPIO Controls](internals_gpio_control.md)
+  * [Proton C Conversion](proton_c_conversion.md)
 
-* Using QMK
-  * Guides
-    * [Customizing Functionality](custom_quantum_functions.md)
-    * [Driver Installation with Zadig](driver_installation_zadig.md)
-    * [Keymap Overview](keymap.md)
-    * [Vagrant Guide](getting_started_vagrant.md)
-    * Flashing
-      * [Flashing](flashing.md)
-      * [Flashing ATmega32A (ps2avrgb)](flashing_bootloadhid.md)
-    * IDEs
-      * [Using Eclipse with QMK](other_eclipse.md)
-      * [Using VSCode with QMK](other_vscode.md)
-    * Git Best Practices
-      * [Introduction](newbs_git_best_practices.md)
-      * [Your Fork](newbs_git_using_your_master_branch.md)
-      * [Merge Conflicts](newbs_git_resolving_merge_conflicts.md)
-      * [Fixing Your Branch](newbs_git_resynchronize_a_branch.md)
-    * Keyboard Building
-      * [Hand Wiring Guide](hand_wire.md)
-      * [ISP Flashing Guide](isp_flashing_guide.md)
+* For a Deeper Understanding
+  * [How Keyboards Work](how_keyboards_work.md)
+  * [Understanding QMK](understanding_qmk.md)
 
-  * Simple Keycodes
-    * [Full List](keycodes.md)
-    * [Basic Keycodes](keycodes_basic.md)
-    * [Modifier Keys](feature_advanced_keycodes.md)
-    * [Quantum Keycodes](quantum_keycodes.md)
+* Other Topics
+  * [Using Eclipse with QMK](other_eclipse.md)
+  * [Using VSCode with QMK](other_vscode.md)
+  * [Support](support.md)
+  * [Translating the QMK Docs](translating.md)
 
-  * Advanced Keycodes
-    * [Command](feature_command.md)
-    * [Dynamic Macros](feature_dynamic_macros.md)
-    * [Grave Escape](feature_grave_esc.md)
-    * [Leader Key](feature_leader_key.md)
-    * [Mod-Tap](mod_tap.md)
-    * [Macros](feature_macros.md)
-    * [Mouse Keys](feature_mouse_keys.md)
-    * [Space Cadet Shift](feature_space_cadet.md)
-    * [US ANSI Shifted Keys](keycodes_us_ansi_shifted.md)
-
-  * Software Features
-    * [Auto Shift](feature_auto_shift.md)
-    * [Combos](feature_combo.md)
-    * [Debounce API](feature_debounce_type.md)
-    * [Key Lock](feature_key_lock.md)
-    * [Layers](feature_layers.md)
-    * [One Shot Keys](one_shot_keys.md)
-    * [Pointing Device](feature_pointing_device.md)
-    * [Raw HID](feature_rawhid.md)
-    * [Swap Hands](feature_swap_hands.md)
-    * [Tap Dance](feature_tap_dance.md)
-    * [Tap-Hold Configuration](tap_hold.md)
-    * [Terminal](feature_terminal.md)
-    * [Unicode](feature_unicode.md)
-    * [Userspace](feature_userspace.md)
-    * [WPM Calculation](feature_wpm.md)
-
-  * Hardware Features
-    * Displays
-      * [HD44780 LCD Controller](feature_hd44780.md)
-      * [OLED Driver](feature_oled_driver.md)
-    * Lighting
-      * [Backlight](feature_backlight.md)
-      * [LED Matrix](feature_led_matrix.md)
-      * [RGB Lighting](feature_rgblight.md)
-      * [RGB Matrix](feature_rgb_matrix.md)
-    * [Audio](feature_audio.md)
-    * [Bluetooth](feature_bluetooth.md)
-    * [Bootmagic](feature_bootmagic.md)
-    * [Custom Matrix](custom_matrix.md)
-    * [DIP Switch](feature_dip_switch.md)
-    * [Encoders](feature_encoders.md)
-    * [Haptic Feedback](feature_haptic_feedback.md)
-    * [Proton C Conversion](proton_c_conversion.md)
-    * [PS/2 Mouse](feature_ps2_mouse.md)
-    * [Split Keyboard](feature_split_keyboard.md)
-    * [Stenography](feature_stenography.md)
-    * [Thermal Printer](feature_thermal_printer.md)
-    * [Velocikey](feature_velocikey.md)
-
-* Developing QMK
-  * Breaking Changes
-    * [Overview](breaking_changes.md)
-    * [My Pull Request Was Flagged](breaking_changes_instructions.md)
-    * History
-      * [2020 Feb 29](ChangeLog/20200229.md)
-      * [2019 Aug 30](ChangeLog/20190830.md)
-
-  * C Development
-    * [ARM Debugging Guide](arm_debugging.md)
-    * [AVR Processors](hardware_avr.md)
-    * [Coding Conventions](coding_conventions_c.md)
-    * [Compatible Microcontrollers](compatible_microcontrollers.md)
-    * [Drivers](hardware_drivers.md)
-      * [ADC Driver](adc_driver.md)
-      * [I2C Driver](i2c_driver.md)
-      * [SPI Driver](spi_driver.md)
-      * [WS2812 Driver](ws2812_driver.md)
-      * [EEPROM Driver](eeprom_driver.md)
-    * [GPIO Controls](internals_gpio_control.md)
-    * [Keyboard Guidelines](hardware_keyboard_guidelines.md)
-
-  * Python Development
-    * [Coding Conventions](coding_conventions_python.md)
-    * [QMK CLI Development](cli_development.md)
-
-  * Configurator Development
-    * QMK API
-      * [Development Environment](api_development_environment.md)
-      * [Architecture Overview](api_development_overview.md)
-
-  * Hardware Platform Development
-    * Arm/ChibiOS
-      * [Early initialization](platformdev_chibios_earlyinit.md)
-
-  * QMK Reference
-    * [Contributing to QMK](contributing.md)
-    * [Translating the QMK Docs](translating.md)
-    * [Config Options](config_options.md)
-    * [Make Documentation](getting_started_make_guide.md)
-    * [Documentation Best Practices](documentation_best_practices.md)
-    * [Documentation Templates](documentation_templates.md)
-    * [Community Layouts](feature_layouts.md)
-    * [Unit Testing](unit_testing.md)
-    * [Useful Functions](ref_functions.md)
-    * [info.json Format](reference_info_json.md)
-
-  * For a Deeper Understanding
-    * [How Keyboards Work](how_keyboards_work.md)
-    * [How a Matrix Works](how_a_matrix_works.md)
-    * [Understanding QMK](understanding_qmk.md)
-
-  * QMK Internals (In Progress)
-    * [Defines](internals_defines.md)
-    * [Input Callback Reg](internals_input_callback_reg.md)
-    * [Midi Device](internals_midi_device.md)
-    * [Midi Device Setup Process](internals_midi_device_setup_process.md)
-    * [Midi Util](internals_midi_util.md)
-    * [Send Functions](internals_send_functions.md)
-    * [Sysex Tools](internals_sysex_tools.md)
+* QMK Internals (In Progress)
+  * [Defines](internals_defines.md)
+  * [Input Callback Reg](internals_input_callback_reg.md)
+  * [Midi Device](internals_midi_device.md)
+  * [Midi Device Setup Process](internals_midi_device_setup_process.md)
+  * [Midi Util](internals_midi_util.md)
+  * [Send Functions](internals_send_functions.md)
+  * [Sysex Tools](internals_sysex_tools.md)

docs/adc_driver.md

@@ -2,7 +2,7 @@
 
 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.md).
 
-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.
+This driver is currently AVR-only. The values returned are 10-bit integers (0-1023) mapped between 0V and VCC (usually 5V or 3.3V).
 
 ## Usage
 
@@ -20,8 +20,6 @@ Then place this include at the top of your code:
 
 ## Channels
 
-### AVR
-
 |Channel|AT90USB64/128|ATmega16/32U4|ATmega32A|ATmega328P|
 |-------|-------------|-------------|---------|----------|
 |0      |`F0`         |`F0`         |`A0`     |`C0`      |
@@ -41,84 +39,8 @@ Then place this include at the top of your code:
 
 <sup>\* The ATmega328P possesses two extra ADC channels; however, they are not present on the DIP pinout, and are not shared with GPIO pins. You can use `adc_read()` directly to gain access to these.</sup>
 
-### ARM
-
-Note that some of these pins are doubled-up on ADCs with the same channel. This is because the pins can be used for either ADC.
-
-Also note that the F0 and F3 use different numbering schemes. The F0 has a single ADC and the channels are 0-based, whereas the F3 has 4 ADCs and the channels are 1 based. This is because the F0 uses the `ADCv1` implementation of the ADC, whereas the F3 uses the `ADCv3` implementation.
-
-|ADC|Channel|STM32F0XX|STM32F3XX|
-|---|-------|---------|---------|
-|1  |0      |`A0`     |         |
-|1  |1      |`A1`     |`A0`     |
-|1  |2      |`A2`     |`A1`     |
-|1  |3      |`A3`     |`A2`     |
-|1  |4      |`A4`     |`A3`     |
-|1  |5      |`A5`     |`F4`     |
-|1  |6      |`A6`     |`C0`     |
-|1  |7      |`A7`     |`C1`     |
-|1  |8      |`B0`     |`C2`     |
-|1  |9      |`B1`     |`C3`     |
-|1  |10     |`C0`     |`F2`     |
-|1  |11     |`C1`     |         |
-|1  |12     |`C2`     |         |
-|1  |13     |`C3`     |         |
-|1  |14     |`C4`     |         |
-|1  |15     |`C5`     |         |
-|1  |16     |         |         |
-|2  |1      |         |`A4`     |
-|2  |2      |         |`A5`     |
-|2  |3      |         |`A6`     |
-|2  |4      |         |`A7`     |
-|2  |5      |         |`C4`     |
-|2  |6      |         |`C0`     |
-|2  |7      |         |`C1`     |
-|2  |8      |         |`C2`     |
-|2  |9      |         |`C3`     |
-|2  |10     |         |`F2`     |
-|2  |11     |         |`C5`     |
-|2  |12     |         |`B2`     |
-|2  |13     |         |         |
-|2  |14     |         |         |
-|2  |15     |         |         |
-|2  |16     |         |         |
-|3  |1      |         |`B1`     |
-|3  |2      |         |`E9`     |
-|3  |3      |         |`E13`    |
-|3  |4      |         |         |
-|3  |5      |         |         |
-|3  |6      |         |`E8`     |
-|3  |7      |         |`D10`    |
-|3  |8      |         |`D11`    |
-|3  |9      |         |`D12`    |
-|3  |10     |         |`D13`    |
-|3  |11     |         |`D14`    |
-|3  |12     |         |`B0`     |
-|3  |13     |         |`E7`     |
-|3  |14     |         |`E10`    |
-|3  |15     |         |`E11`    |
-|3  |16     |         |`E12`    |
-|4  |1      |         |`E14`    |
-|4  |2      |         |`B12`    |
-|4  |3      |         |`B13`    |
-|4  |4      |         |`B14`    |
-|4  |5      |         |`B15`    |
-|4  |6      |         |`E8`     |
-|4  |7      |         |`D10`    |
-|4  |8      |         |`D11`    |
-|4  |9      |         |`D12`    |
-|4  |10     |         |`D13`    |
-|4  |11     |         |`D14`    |
-|4  |12     |         |`D8`     |
-|4  |13     |         |`D9`     |
-|4  |14     |         |         |
-|4  |15     |         |         |
-|4  |16     |         |         |
-
 ## Functions
 
-### AVR
-
 |Function                    |Description                                                                                                        |
 |----------------------------|-------------------------------------------------------------------------------------------------------------------|
 |`analogReference(mode)`     |Sets the analog voltage reference source. Must be one of `ADC_REF_EXTERNAL`, `ADC_REF_POWER` or `ADC_REF_INTERNAL`.|
@@ -126,28 +48,3 @@ Also note that the F0 and F3 use different numbering schemes. The F0 has a singl
 |`analogReadPin(pin)`        |Reads the value from the specified QMK pin, eg. `F6` for ADC6 on the ATmega32U4.                                   |
 |`pinToMux(pin)`             |Translates a given QMK pin to a mux value. If an unsupported pin is given, returns the mux value for "0V (GND)".   |
 |`adc_read(mux)`             |Reads the value from the ADC according to the specified mux. See your MCU's datasheet for more information.        |
-
-### ARM
-
-Note that care was taken to match all of the functions used for AVR devices, however complications in the ARM platform prevent that from always being possible. For example, the `STM32` chips do not have assigned Arduino pins. We could use the default pin numbers, but those numbers change based on the package type of the device. For this reason, please specify your target pins with their identifiers (`A0`, `F3`, etc.). Also note that there are some variants of functions that accept the target ADC for the pin. Some pins can be used for multiple ADCs, and this specified can help you pick which ADC will be used to interact with that pin.
-
-|Function                    |Description                                                                                                         |
-|----------------------------|--------------------------------------------------------------------------------------------------------------------|
-|`analogReadPin(pin)`        |Reads the value from the specified QMK pin, eg. `A0` for channel 0 on the STM32F0 and ADC1 channel 1 on the STM32F3. Note that if a pin can be used for multiple ADCs, it will pick the lower numbered ADC for this function. eg. `C0` will be channel 6 of ADC 1 when it could be used for ADC 2 as well.|
-|`analogReadPinAdc(pin, adc)`|Reads the value from the specified QMK pin and ADC, eg. `C0, 1` will read from channel 6, ADC 2 instead of ADC 1. Note that the ADCs are 0-indexed for this function.|
-|`pinToMux(pin)`             |Translates a given QMK pin to a channel and ADC combination. If an unsupported pin is given, returns the mux value for "0V (GND)".|
-|`adc_read(mux)`             |Reads the value from the ADC according to the specified pin and adc combination. See your MCU's datasheet for more information.|
-
-## Configuration
-
-## ARM
-
-The ARM implementation of the ADC has a few additional options that you can override in your own keyboards and keymaps to change how it operates.
-
-|`#define`          |Type  |Default              |Description|
-|-------------------|------|---------------------|-----------|
-|ADC_CIRCULAR_BUFFER|`bool`|`false`              |If `TRUE`, then the implementation will use a circular buffer.|
-|ADC_NUM_CHANNELS   |`int` |`1`                  |Sets the number of channels that will be scanned as part of an ADC operation. The current implementation only supports `1`.|
-|ADC_BUFFER_DEPTH   |`int` |`2`                  |Sets the depth of each result. Since we are only getting a 12-bit result by default, we set this to `2` bytes so we can contain our one value. This could be set to 1 if you opt for a 8-bit or lower result.|
-|ADC_SAMPLING_RATE  |`int` |`ADC_SMPR_SMP_1P5`   |Sets the sampling rate of the ADC. By default, it is set to the fastest setting. Please consult the corresponding `hal_adc_lld.h` in ChibiOS for your specific microcontroller for further documentation on your available options.|
-|ADC_RESOLUTION     |`int` |`ADC_CFGR1_RES_12BIT`|The resolution of your result. We choose 12 bit by default, but you can opt for 12, 10, 8, or 6 bit. Please consult the corresponding `hal_adc_lld.h` in ChibiOS for your specific microcontroller for further documentation on your available options.|

docs/api_development_environment.md

@@ -1,3 +0,0 @@
-# Development Environment Setup
-
-To setup a development stack head over to the [qmk_web_stack](https://github.com/qmk/qmk_web_stack).

docs/api_development_overview.md

@@ -1,44 +0,0 @@
-# QMK Compiler Development Guide
-
-This page attempts to introduce developers to the QMK Compiler. It does not go into nitty gritty details- for that you should read code. What this will give you is a framework to hang your understanding on as you read the code.
-
-# Overview
-
-The QMK Compile API consists of a few movings parts:
-
-![Architecture Diagram](https://raw.githubusercontent.com/qmk/qmk_api/master/docs/architecture.svg)
-
-API Clients interact exclusively with the API service. This is where they submit jobs, check status, and download results. The API service inserts compile jobs into [Redis Queue](https://python-rq.org) and checks both RQ and S3 for the results of those jobs.
-
-Workers fetch new compile jobs from RQ, compile them, and then upload the source and the binary to an S3 compatible storage engine.
-
-# Workers
-
-QMK Compiler Workers are responsible for doing the actual building. When a worker pulls a job from RQ it does several things to complete that job:
-
-* Make a fresh qmk_firmware checkout
-* Use the supplied layers and keyboard metadata to build a `keymap.c`
-* Build the firmware
-* Zip a copy of the source
-* Upload the firmware, source zip, and a metadata file to S3.
-* Report the status of the job to RQ
-
-# API Service
-
-The API service is a relatively simple Flask application. There are a few main views you should understand.
-
-## @app.route('/v1/compile', methods=['POST'])
-
-This is the main entrypoint for the API. A client's interaction starts here. The client POST's a JSON document describing their keyboard, and the API does some (very) basic validation of that JSON before submitting the compile job.
-
-## @app.route('/v1/compile/<string:job_id>', methods=['GET'])
-
-This is the most frequently called endpoint. It pulls the job details from redis, if they're still available, or the cached job details on S3 if they're not.
-
-## @app.route('/v1/compile/<string:job_id>/download', methods=['GET'])
-
-This method allows users to download the compiled firmware file.
-
-## @app.route('/v1/compile/<string:job_id>/source', methods=['GET'])
-
-This method allows users to download the source for their firmware.

docs/api_docs.md

@@ -1,68 +0,0 @@
-# QMK API
-
-This page describes using the QMK API. If you are an application developer you can use this API to compile firmware for any [QMK](https://qmk.fm) Keyboard.
-
-## Overview
-
-This service is an asynchronous API for compiling custom keymaps. You POST some JSON to the API, periodically check the status, and when your firmware has finished compiling you can download the resulting firmware and (if desired) source code for that firmware.
-
-#### Example JSON Payload:
-
-```json
-{
-  "keyboard": "clueboard/66/rev2",
-  "keymap": "my_awesome_keymap",
-  "layout": "LAYOUT_all",
-  "layers": [
-    ["KC_GRV","KC_1","KC_2","KC_3","KC_4","KC_5","KC_6","KC_7","KC_8","KC_9","KC_0","KC_MINS","KC_EQL","KC_GRV","KC_BSPC","KC_PGUP","KC_TAB","KC_Q","KC_W","KC_E","KC_R","KC_T","KC_Y","KC_U","KC_I","KC_O","KC_P","KC_LBRC","KC_RBRC","KC_BSLS","KC_PGDN","KC_CAPS","KC_A","KC_S","KC_D","KC_F","KC_G","KC_H","KC_J","KC_K","KC_L","KC_SCLN","KC_QUOT","KC_NUHS","KC_ENT","KC_LSFT","KC_NUBS","KC_Z","KC_X","KC_C","KC_V","KC_B","KC_N","KC_M","KC_COMM","KC_DOT","KC_SLSH","KC_RO","KC_RSFT","KC_UP","KC_LCTL","KC_LGUI","KC_LALT","KC_MHEN","KC_SPC","KC_SPC","KC_HENK","KC_RALT","KC_RCTL","MO(1)","KC_LEFT","KC_DOWN","KC_RIGHT"],
-    ["KC_ESC","KC_F1","KC_F2","KC_F3","KC_F4","KC_F5","KC_F6","KC_F7","KC_F8","KC_F9","KC_F10","KC_F11","KC_F12","KC_TRNS","KC_DEL","BL_STEP","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","_______","KC_TRNS","KC_PSCR","KC_SLCK","KC_PAUS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","MO(2)","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_PGUP","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","MO(1)","KC_LEFT","KC_PGDN","KC_RGHT"],
-    ["KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","RESET","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","MO(2)","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","MO(1)","KC_TRNS","KC_TRNS","KC_TRNS"]
-  ]
-}
-```
-
-As you can see the payload describes all aspects of a keyboard necessary to create and generate a firmware. Each layer is a single list of QMK keycodes the same length as the keyboard's `LAYOUT` macro. If a keyboard supports mulitple `LAYOUT` macros you can specify which macro to use.
-
-## Submitting a Compile Job
-
-To compile your keymap into a firmware simply POST your JSON to the `/v1/compile` endpoint. In the following example we've placed the JSON payload into a file named `json_data`.
-
-```
-$ curl -H "Content-Type: application/json" -X POST -d "$(< json_data)" http://api.qmk.fm/v1/compile
-{
-  "enqueued": true,
-  "job_id": "ea1514b3-bdfc-4a7b-9b5c-08752684f7f6"
-}
-```
-
-## Checking The Status
-
-After submitting your keymap you can check the status using a simple HTTP GET call:
-
-```
-$ curl http://api.qmk.fm/v1/compile/ea1514b3-bdfc-4a7b-9b5c-08752684f7f6
-{
-  "created_at": "Sat, 19 Aug 2017 21:39:12 GMT",
-  "enqueued_at": "Sat, 19 Aug 2017 21:39:12 GMT",
-  "id": "f5f9b992-73b4-479b-8236-df1deb37c163",
-  "status": "running",
-  "result": null
-}
-```
-
-This shows us that the job has made it through the queue and is currently running. There are 5 possible statuses:
-
-* **failed**: Something about the compiling service has broken.
-* **finished**: The compilation is complete and you should check `result` to see the results.
-* **queued**: The keymap is waiting for a compilation server to become available.
-* **running**: The compilation is in progress and should be complete soon.
-* **unknown**: A serious error has occurred and you should [file a bug](https://github.com/qmk/qmk_compiler/issues).
-
-## Examining Finished Results
-
-Once your compile job has finished you'll check the `result` key. The value of this key is a hash containing several key bits of information:
-
-* `firmware_binary_url`: A list of URLs for the the flashable firmware
-* `firmware_keymap_url`: A list of URLs for the the `keymap.c`
-* `firmware_source_url`: A list of URLs for the full firmware source code
-* `output`: The stdout and stderr for this compile job. Errors will be found here.

docs/api_overview.md

@@ -1,15 +0,0 @@
-# QMK API
-
-The QMK API provides an asynchronous API that Web and GUI tools can use to compile arbitrary keymaps for any keyboard supported by [QMK](http://qmk.fm/). The stock keymap template supports all QMK keycodes that do not require supporting C code. Keyboard maintainers can supply their own custom templates to enable more functionality.
-
-## App Developers
-
-If you are an app developer interested in using this API in your application you should head over to [Using The API](api_docs.md).
-
-## Keyboard Maintainers
-
-If you would like to enhance your keyboard's support in the QMK Compiler API head over to the [Keyboard Support](reference_configurator_support.md) section.
-
-## Backend Developers
-
-If you are interested in working on the API itself you should start by setting up a [Development Environment](api_development_environment.md), then check out [Hacking On The API](api_development_overview.md).

docs/becoming_a_qmk_collaborator.md

@@ -0,0 +1,9 @@
+# Becoming a QMK Collaborator
+
+A QMK collaborator is a keyboard maker or designer that is interested in helping QMK grow and fully support their keyboard(s), and encouraging their users and customers to submit features, ideas, and keymaps. We're always looking to add more keyboards and collaborators, but we ask that they fulfill these requirements:
+
+* **Have a PCB available for sale.** Unfortunately there's just too much variation and complications with handwired keyboards.
+* **Maintain your keyboard in QMK.** This may just require an initial setup to get your keyboard working, but it could also include accommodating changes made to QMK's core that might break or render any custom code redundant.
+* **Approve and merge keymap pull requests for your keyboard.** We like to encourage users to contribute their keymaps for others to see and work from when creating their own.
+
+If you feel you meet these requirements, shoot us an email at hello@qmk.fm with an introduction and some links to your keyboard!

docs/breaking_changes.md

@@ -6,21 +6,20 @@ The breaking change period is when we will merge PR's that change QMK in dangero
 
 ## What has been included in past Breaking Changes?
 
-* [2020 Feb 29](ChangeLog/20200229.md)
 * [2019 Aug 30](ChangeLog/20190830.md)
 
 ## When is the next Breaking Change?
 
-The next Breaking Change is scheduled for May 30, 2020.
+The next Breaking Change is scheduled for Nov 29.
 
 ### Important Dates
 
-* [x] 2020 Feb 29 - `future` is created. It will be rebased weekly.
-* [ ] 2020 May 2 - `future` closed to new PR's.
-* [ ] 2020 May 2 - Call for testers.
-* [ ] 2020 May 28 - `master` is locked, no PR's merged.
-* [ ] 2020 May 30 - Merge `future` to `master`.
-* [ ] 2020 May 30 - `master` is unlocked. PR's can be merged again.
+* [x] 2019 Sep 21 - `future` is created. It will be rebased weekly.
+* [ ] 2019 Nov 01 - `future` closed to new PR's.
+* [ ] 2019 Nov 01 - Call for testers.
+* [ ] 2019 Nov 27 - `master` is locked, no PR's merged.
+* [ ] 2019 Nov 29 - Merge `future` to `master`.
+* [ ] 2019 Nov 30 - `master` is unlocked. PR's can be merged again.
 
 ## What changes will be included?
 

docs/breaking_changes_instructions.md

@@ -1,42 +0,0 @@
-# Breaking Changes: My Pull Request Was Flagged
-
-A QMK member may have replied to your pull request stating that your submission is a breaking change. In their judgment, the changes you have proposed have greater implications for either QMK, or its users.
-
-Some things that may cause a pull request to be flagged are:
-
-- **Edits to User Keymaps**
-  A user may submit their keymap to QMK, then some time later open a pull request with further updates, only to find it can't be merged because it was edited in the `qmk/qmk_firmware` repository. As not all users are proficient at using Git or GitHub, the user may find themself unable to fix the issue on their own.
-- **Changes to Expected Behavior**
-  Changes to QMK behavior may cause users to believe their hardware or QMK is broken if they flash new firmware that incorporates changes to existing QMK features, and find themselves without a means to restore the desired behavior.
-- **Changes Requiring User Action**
-  Changes may also require action to be taken by users, such as updating a toolchain or taking some action in Git.
-- **Changes Necessitating Increased Scrutiny**
-  On occasion, a submission may have implications for QMK as a project. This could be copyright/licensing issues, coding conventions, large feature overhauls, "high-risk" changes that need wider testing by our community, or something else entirely.
-- **Changes Requiring Communication to End Users**
-  This includes warnings about future deprecations, outdated practices, and anything else that needs to be communicated but doesn't fit into one of the above categories.
-
-## What Do I Do?
-
-If it is determined that your submission is a breaking change, there are a few things you can do to smooth the process:
-
-### Consider Splitting Up Your PR
-
-If you are contributing core code, and the only reason it needs to go through breaking changes is that you are updating keymaps to match your change, consider whether you can submit your feature in a way that the old keymaps continue to work. Then submit a separate PR that goes through the breaking changes process to remove the old code.
-
-### Contribute a ChangeLog Entry
-
-We require submissions that go through the Breaking Change process to include a changelog entry. The entry should be a short summary of the changes your pull request makes – [each section here started as a changelog](ChangeLog/20190830.md "n.b. This should link to the 2019 Aug 30 Breaking Changes doc  - @noroadsleft").
-
-Your changelog should be located at `docs/ChangeLog/YYYYMMDD/PR####.md`, where `YYYYMMDD` is the date on which QMK's breaking change branch – usually named `future` – will be merged into the `master` branch, and `####` is the number of your pull request.
-
-If your submission requires action on the part of users, your changelog should instruct users what action(s) must be taken, or link to a location that does so.
-
-### Document Your Changes
-
-Understanding the purpose for your submission, and possible implications or actions it will require can make the review process more straightforward. A changelog may suffice for this purpose, but more extensive changes may require a level of detail that is ill-suited for a changelog.
-
-Commenting on your pull request and being responsive to questions, comments, and change requests is much appreciated.
-
-### Ask for Help
-
-Having your submission flagged may have caught you off guard. If you find yourself intimidated or overwhelmed, let us know. Comment on your pull request, or [reach out to the QMK team on Discord](https://discord.gg/Uq7gcHh).

docs/cli.md

@@ -1,14 +1,24 @@
-# QMK CLI :id=qmk-cli
+# QMK CLI
 
-## Overview :id=overview
+This page describes how to setup and use the QMK CLI.
+
+# Overview
 
 The QMK CLI makes building and working with QMK keyboards easier. We have provided a number of commands to simplify and streamline tasks such as obtaining and compiling the QMK firmware, creating keymaps, and more.
 
-### Requirements :id=requirements
+* [Global CLI](#global-cli)
+* [Local CLI](#local-cli)
+* [CLI Commands](#cli-commands)
 
-QMK requires Python 3.6 or greater. We try to keep the number of requirements small but you will also need to install the packages listed in [`requirements.txt`](https://github.com/qmk/qmk_firmware/blob/master/requirements.txt). These are installed automatically when you install the QMK CLI.
+# Requirements
 
-### Install Using Homebrew (macOS, some Linux) :id=install-using-homebrew
+The CLI requires Python 3.5 or greater. We try to keep the number of requirements small but you will also need to install the packages listed in [`requirements.txt`](https://github.com/qmk/qmk_firmware/blob/master/requirements.txt).
+
+# Global CLI
+
+QMK provides an installable CLI that can be used to setup your QMK build environment, work with QMK, and which makes working with multiple copies of `qmk_firmware` easier. We recommend installing and updating this periodically.
+
+## Install Using Homebrew (macOS, some Linux)
 
 If you have installed [Homebrew](https://brew.sh) you can tap and install QMK:
 
@@ -19,9 +29,9 @@ export QMK_HOME='~/qmk_firmware' # Optional, set the location for `qmk_firmware`
 qmk setup  # This will clone `qmk/qmk_firmware` and optionally set up your build environment
 ```
 
-### Install Using easy_install or pip :id=install-using-easy_install-or-pip
+## Install Using easy_install or pip
 
-If your system is not listed above you can install QMK manually. First ensure that you have python 3.6 (or later) installed and have installed pip. Then install QMK with this command:
+If your system is not listed above you can install QMK manually. First ensure that you have python 3.5 (or later) installed and have installed pip. Then install QMK with this command:
 
 ```
 pip3 install qmk
@@ -29,7 +39,7 @@ export QMK_HOME='~/qmk_firmware' # Optional, set the location for `qmk_firmware`
 qmk setup  # This will clone `qmk/qmk_firmware` and optionally set up your build environment
 ```
 
-### Packaging For Other Operating Systems :id=packaging-for-other-operating-systems
+## Packaging For Other Operating Systems
 
 We are looking for people to create and maintain a `qmk` package for more operating systems. If you would like to create a package for your OS please follow these guidelines:
 
@@ -37,3 +47,176 @@ We are looking for people to create and maintain a `qmk` package for more operat
     * Document why in a comment when you do deviate
 * Install using a virtualenv
 * Instruct the user to set the environment variable `QMK_HOME` to have the firmware source checked out somewhere other than `~/qmk_firmware`.
+
+# Local CLI
+
+If you do not want to use the global CLI there is a local CLI bundled with `qmk_firmware`. You can find it in `qmk_firmware/bin/qmk`. You can run the `qmk` command from any directory and it will always operate on that copy of `qmk_firmware`.
+
+**Example**:
+
+```
+$ ~/qmk_firmware/bin/qmk hello
+Ψ Hello, World!
+```
+
+## Local CLI Limitations
+
+There are some limitations to the local CLI compared to the global CLI:
+
+* The local CLI does not support `qmk setup` or `qmk clone`
+* The local CLI always operates on the same `qmk_firmware` tree, even if you have multiple repositories cloned.
+* The local CLI does not run in a virtualenv, so it's possible that dependencies will conflict
+
+# CLI Commands
+
+## `qmk cformat`
+
+This command formats C code using clang-format. Run it with no arguments to format all core code, or pass filenames on the command line to run it on specific files.
+
+**Usage**:
+
+```
+qmk cformat [file1] [file2] [...] [fileN]
+```
+
+## `qmk compile`
+
+This command allows you to compile firmware from any directory. You can compile JSON exports from <https://config.qmk.fm> or compile keymaps in the repo.
+
+**Usage for Configurator Exports**:
+
+```
+qmk compile <configuratorExport.json>
+```
+
+**Usage for Keymaps**:
+
+```
+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).
+
+**Usage**:
+
+```
+qmk config [-ro] [config_token1] [config_token2] [...] [config_tokenN]
+```
+
+## `qmk docs`
+
+This command starts a local HTTP server which you can use for browsing or improving the docs. Default port is 8936.
+
+**Usage**:
+
+```
+qmk docs [-p PORT]
+```
+
+## `qmk doctor`
+
+This command examines your environment and alerts you to potential build or flash problems.
+
+**Usage**:
+
+```
+qmk doctor
+```
+
+## `qmk json-keymap`
+
+Creates a keymap.c from a QMK Configurator export.
+
+**Usage**:
+
+```
+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`
+
+**Usage**:
+
+```
+qmk list-keyboards
+```
+
+## `qmk new-keymap`
+
+This command creates a new keymap based on a keyboard's existing default keymap.
+
+**Usage**:
+
+```
+qmk new-keymap [-kb KEYBOARD] [-km KEYMAP]
+```
+
+## `qmk pyformat`
+
+This command formats python code in `qmk_firmware`.
+
+**Usage**:
+
+```
+qmk pyformat
+```
+
+## `qmk pytest`
+
+This command runs the python test suite. If you make changes to python code you should ensure this runs successfully.
+
+**Usage**:
+
+```
+qmk pytest
+```

docs/cli_commands.md

@@ -1,258 +0,0 @@
-# QMK CLI Commands
-
-# User Commands
-
-## `qmk compile`
-
-This command allows you to compile firmware from any directory. You can compile JSON exports from <https://config.qmk.fm>, compile keymaps in the repo, or compile the keyboard in the current working directory.
-
-**Usage for Configurator Exports**:
-
-```
-qmk compile <configuratorExport.json>
-```
-
-**Usage for Keymaps**:
-
-```
-qmk compile -kb <keyboard_name> -km <keymap_name>
-```
-
-**Usage in Keyboard Directory**:  
-
-Must be in keyboard directory with a default keymap, or in keymap directory for keyboard, or supply one with `--keymap <keymap_name>`
-```
-qmk compile
-```
-
-**Usage for building all keyboards that support a specific keymap**:
-
-```
-qmk compile -kb all -km <keymap_name>
-```
-
-**Example**:
-```
-$ qmk config compile.keymap=default
-$ cd ~/qmk_firmware/keyboards/planck/rev6
-$ qmk compile
-Ψ Compiling keymap with make planck/rev6:default
-...
-```
-or with optional keymap argument
-
-```
-$ cd ~/qmk_firmware/keyboards/clueboard/66/rev4 
-$ qmk compile -km 66_iso
-Ψ Compiling keymap with make clueboard/66/rev4:66_iso
-...
-```
-or in keymap directory
-
-```
-$ cd ~/qmk_firmware/keyboards/gh60/satan/keymaps/colemak
-$ qmk compile
-Ψ Compiling keymap with make make gh60/satan:colemak
-...
-```
-
-**Usage in Layout Directory**:  
-
-Must be under `qmk_firmware/layouts/`, and in a keymap folder.
-```
-qmk compile -kb <keyboard_name>
-```
-
-**Example**:
-```
-$ cd ~/qmk_firmware/layouts/community/60_ansi/mechmerlin-ansi
-$ qmk compile -kb dz60
-Ψ Compiling keymap with make dz60:mechmerlin-ansi
-...
-```
-
-## `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 the [Flashing Firmware](flashing.md) guide 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).
-
-**Usage**:
-
-```
-qmk config [-ro] [config_token1] [config_token2] [...] [config_tokenN]
-```
-
-## `qmk doctor`
-
-This command examines your environment and alerts you to potential build or flash problems. It can fix many of them if you want it to.
-
-**Usage**:
-
-```
-qmk doctor [-y] [-n]
-```
-
-**Examples**:
-
-Check your environment for problems and prompt to fix them:
-
-    qmk doctor
-
-Check your environment and automatically fix any problems found:
-
-    qmk doctor -y
-
-Check your environment and report problems only:
-
-    qmk doctor -n
-
-## `qmk json2c`
-
-Creates a keymap.c from a QMK Configurator export.
-
-**Usage**:
-
-```
-qmk json2c [-o OUTPUT] filename
-```
-
-## `qmk list-keyboards`
-
-This command lists all the keyboards currently defined in `qmk_firmware`
-
-**Usage**:
-
-```
-qmk list-keyboards
-```
-
-## `qmk list-keymaps`
-
-This command lists all the keymaps for a specified keyboard (and revision).
-
-**Usage**:
-
-```
-qmk list-keymaps -kb planck/ez
-```
-
-## `qmk new-keymap`
-
-This command creates a new keymap based on a keyboard's existing default keymap.
-
-**Usage**:
-
-```
-qmk new-keymap [-kb KEYBOARD] [-km KEYMAP]
-```
-
----
-
-# Developer Commands
-
-## `qmk cformat`
-
-This command formats C code using clang-format. 
-
-Run it with no arguments to format all core code that has been changed. Default checks `origin/master` with `git diff`, branch can be changed using `-b <branch_name>`
-
-Run it with `-a` to format all core code, or pass filenames on the command line to run it on specific files.
-
-**Usage for specified files**:
-
-```
-qmk cformat [file1] [file2] [...] [fileN]
-```
-
-**Usage for all core files**:
-
-```
-qmk cformat -a
-```
-
-**Usage for only changed files against origin/master**:
-
-```
-qmk cformat
-```
-
-**Usage for only changed files against branch_name**:
-
-```
-qmk cformat -b branch_name
-```
-
-## `qmk docs`
-
-This command starts a local HTTP server which you can use for browsing or improving the docs. Default port is 8936.
-
-**Usage**:
-
-```
-qmk docs [-p PORT]
-```
-
-## `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 pyformat`
-
-This command formats python code in `qmk_firmware`.
-
-**Usage**:
-
-```
-qmk pyformat
-```
-
-## `qmk pytest`
-
-This command runs the python test suite. If you make changes to python code you should ensure this runs successfully.
-
-**Usage**:
-
-```
-qmk pytest
-```
-

docs/cli_configuration.md

@@ -4,7 +4,7 @@ This document explains how `qmk config` works.
 
 # Introduction
 
-Configuration for the QMK CLI is a key/value system. Each key consists of a subcommand and an argument name separated by a period. This allows for a straightforward and direct translation between config keys and the arguments they set.
+Configuration for QMK CLI is a key/value system. Each key consists of a subcommand and an argument name separated by a period. This allows for a straightforward and direct translation between config keys and the arguments they set.
 
 ## Simple Example
 

docs/cli_development.md

@@ -6,18 +6,6 @@ This document has useful information for developers wishing to write new `qmk` s
 
 The QMK CLI operates using the subcommand pattern made famous by git. The main `qmk` script is simply there to setup the environment and pick the correct entrypoint to run. Each subcommand is a self-contained module with an entrypoint (decorated by `@cli.subcommand()`) that performs some action and returns a shell returncode, or None.
 
-## Developer mode:
-
-If you intend to maintain keyboards and/or contribute to QMK, you can enable the CLI's "Developer" mode:
-
-`qmk config user.developer=True`
-
-This will allow you to see all available subcommands.  
-**Note:** You will have to install additional requirements:  
-```bash
-python3 -m pip install -r requirements-dev.txt
-```
-
 # Subcommands
 
 [MILC](https://github.com/clueboard/milc) is the CLI framework `qmk` uses to handle argument parsing, configuration, logging, and many other features. It lets you focus on writing your tool without wasting your time writing glue code.
@@ -44,7 +32,7 @@ def hello(cli):
 
 First we import the `cli` object from `milc`. This is how we interact with the user and control the script's behavior. We use `@cli.argument()` to define a command line flag, `--name`. This also creates a configuration variable named `hello.name` (and the corresponding `user.name`) which the user can set so they don't have to specify the argument. The `cli.subcommand()` decorator designates this function as a subcommand. The name of the subcommand will be taken from the name of the function.
 
-Once inside our function we find a typical "Hello, World!" program. We use `cli.log` to access the underlying [Logger Object](https://docs.python.org/3.6/library/logging.html#logger-objects), whose behavior is user controllable. We also access the value for name supplied by the user as `cli.config.hello.name`. The value for `cli.config.hello.name` will be determined by looking at the `--name` argument supplied by the user, if not provided it will use the value in the `qmk.ini` config file, and if neither of those is provided it will fall back to the default supplied in the `cli.argument()` decorator.
+Once inside our function we find a typical "Hello, World!" program. We use `cli.log` to access the underlying [Logger Object](https://docs.python.org/3.5/library/logging.html#logger-objects), whose behavior is user controllable. We also access the value for name supplied by the user as `cli.config.hello.name`. The value for `cli.config.hello.name` will be determined by looking at the `--name` argument supplied by the user, if not provided it will use the value in the `qmk.ini` config file, and if neither of those is provided it will fall back to the default supplied in the `cli.argument()` decorator.
 
 # User Interaction
 
@@ -56,13 +44,13 @@ There are two main methods for outputting text in a subcommand- `cli.log` and `c
 
 You can use special tokens to colorize your text, to make it easier to understand the output of your program. See [Colorizing Text](#colorizing-text) below.
 
-Both of these methods support built-in string formatting using python's [printf style string format operations](https://docs.python.org/3.6/library/stdtypes.html#old-string-formatting). You can use tokens such as `%s` and `%d` within your text strings then pass the values as arguments. See our Hello, World program above for an example.
+Both of these methods support built-in string formatting using python's [printf style string format operations](https://docs.python.org/3.5/library/stdtypes.html#old-string-formatting). You can use tokens such as `%s` and `%d` within your text strings then pass the values as arguments. See our Hello, World program above for an example.
 
 You should never use the format operator (`%`) directly, always pass values as arguments.
 
 ### Logging (`cli.log`)
 
-The `cli.log` object gives you access to a [Logger Object](https://docs.python.org/3.6/library/logging.html#logger-objects). We have configured our log output to show the user a nice emoji for each log level (or the log level name if their terminal does not support unicode.) This way the user can tell at a glance which messages are most important when something goes wrong.
+The `cli.log` object gives you access to a [Logger Object](https://docs.python.org/3.5/library/logging.html#logger-objects). We have configured our log output to show the user a nice emoji for each log level (or the log level name if their terminal does not support unicode.) This way the user can tell at a glance which messages are most important when something goes wrong.
 
 The default log level is `INFO`. If the user runs `qmk -v <subcommand>` the default log level will be set to `DEBUG`.
 

docs/coding_conventions_c.md

@@ -20,11 +20,11 @@ Most of our style is pretty easy to pick up on, but right now it's not entirely
 * We accept both forms of preprocessor if's: `#ifdef DEFINED` and `#if defined(DEFINED)`
   * If you are not sure which to prefer use the `#if defined(DEFINED)` form.
   * Do not change existing code from one style to the other, except when moving to a multiple condition `#if`.
-* When deciding how (or if) to indent preprocessor directives, keep these points in mind:
-  * Readability is more important than consistency.
-  * Follow the file's existing style. If the file is mixed, follow the style that makes sense for the section you are modifying.
-  * When indenting, keep the hash at the start of the line and add whitespace between `#` and `if`, starting with 4 spaces after the `#`.
-  * You can follow the indention level of the surrounding C code, or preprocessor directives can have their own indentation levels. Choose the style that best communicates the intent of your code.
+  * Do not put whitespace between `#` and `if`.
+  * When deciding how (or if) to indent directives keep these points in mind:
+    * Readability is more important than consistency.
+    * Follow the file's existing style. If the file is mixed follow the style that makes sense for the section you are modifying.
+    * When choosing to indent you can follow the indention level of the surrounding C code, or preprocessor directives can have their own indent level. Choose the style that best communicates the intent of your code.
 
 Here is an example for easy reference: