Merge branch 'master' of https://github.com/qmk/qmk_firmware

2025-07-16 12:51:47 +00:00 · 2020-08-01 10:25:30 +09:00 · 2020-08-01 10:25:30 +09:00 · 2d5a237c73
commit 2d5a237c73
parent eb223ab11e 28c78023c5
668 changed files with 25854 additions and 3563 deletions
--- a/.gitignore
+++ b/.gitignore
@ -73,3 +73,6 @@ __pycache__

 # prerequisites for updating ChibiOS
 /util/fmpp*
+
+# Allow to exist but don't include it in the repo
+user_song_list.h
--- a/common_features.mk
+++ b/common_features.mk
@ -246,12 +246,13 @@ ifeq ($(strip $(SERIAL_LINK_ENABLE)), yes)
    VAPTH += $(SERIAL_PATH)
 endif

-ifneq ($(strip $(VARIABLE_TRACE)),)
+VARIABLE_TRACE ?= no
+ifneq ($(strip $(VARIABLE_TRACE)),no)
    SRC += $(QUANTUM_DIR)/variable_trace.c
    OPT_DEFS += -DNUM_TRACED_VARIABLES=$(strip $(VARIABLE_TRACE))
-ifneq ($(strip $(MAX_VARIABLE_TRACE_SIZE)),)
-    OPT_DEFS += -DMAX_VARIABLE_TRACE_SIZE=$(strip $(MAX_VARIABLE_TRACE_SIZE))
-endif
+    ifneq ($(strip $(MAX_VARIABLE_TRACE_SIZE)),)
+        OPT_DEFS += -DMAX_VARIABLE_TRACE_SIZE=$(strip $(MAX_VARIABLE_TRACE_SIZE))
+    endif
 endif

 ifeq ($(strip $(LCD_ENABLE)), yes)
--- a/docs/config_options.md
+++ b/docs/config_options.md
@ -43,8 +43,6 @@ This is a C header file that is one of the first things included, and will persi
  * generally who/whatever brand produced the board
 * `#define PRODUCT Board`
  * the name of the keyboard
-* `#define DESCRIPTION a keyboard`
-  * a short description of what the keyboard is
 * `#define MATRIX_ROWS 5`
  * the number of rows in your keyboard's matrix
 * `#define MATRIX_COLS 15`
--- a/docs/custom_quantum_functions.md
+++ b/docs/custom_quantum_functions.md
@ -319,7 +319,7 @@ This runs code every time that the layers get changed.  This can be useful for l

 ### Example `layer_state_set_*` Implementation

-This example shows how to set the [RGB Underglow](feature_rgblight.md) lights based on the layer, using the Planck as an example
+This example shows how to set the [RGB Underglow](feature_rgblight.md) lights based on the layer, using the Planck as an example.

 ```c
 layer_state_t layer_state_set_user(layer_state_t state) {
@ -343,6 +343,11 @@ layer_state_t layer_state_set_user(layer_state_t state) {
  return state;
 }
 ```
+
+Use the `IS_LAYER_ON_STATE(state, layer)` and `IS_LAYER_OFF_STATE(state, layer)` macros to check the status of a particular layer.
+
+Outside of `layer_state_set_*` functions, you can use the `IS_LAYER_ON(layer)` and `IS_LAYER_OFF(layer)` macros to check global layer state.
+
 ### `layer_state_set_*` Function Documentation

 * Keyboard/Revision: `layer_state_t layer_state_set_kb(layer_state_t state)`
@ -449,7 +454,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
                layer_state_set(layer_state);   // then immediately update the layer color
            }
        }
-        return false; break;
+        return false;
    case RGB_MODE_FORWARD ... RGB_MODE_GRADIENT: // For any of the RGB codes (see quantum_keycodes.h, L400 for reference)
        if (record->event.pressed) { //This disables layer indication, as it's assumed that if you're changing this ... you want that disabled
            if (user_config.rgb_layer_change) {        // only if this is enabled
--- a/docs/driver_installation_zadig.md
+++ b/docs/driver_installation_zadig.md
@ -23,7 +23,7 @@ Zadig will automatically detect the bootloader device. You may sometimes need to

 !> If Zadig lists one or more devices with the `HidUsb` driver, your keyboard is probably not in bootloader mode. The arrow will be colored orange and you will be asked to confirm modifying a system driver. **Do not** proceed if this is the case!

-If the arrow appears green, select the driver, and click **Install Driver**. The `libusb-win32` driver will usually work for AVR, and `WinUSB` for ARM, but if you still cannot flash the board, try installing a different driver from the list. For flashing a USBaspLoader device via command line with msys2, the `libusbk` driver is recommended, otherwise `libusb-win32` will work fine if you are using QMK Toolbox for flashing.
+If the arrow appears green, select the driver, and click **Install Driver**. The `libusb-win32` driver will usually work for AVR, and `WinUSB` for ARM, but if you still cannot flash the board, try installing a different driver from the list. USBAspLoader devices must use the `libusbK` driver.

 ![Zadig with a bootloader driver correctly installed](https://i.imgur.com/b8VgXzx.png)

--- a/docs/es/hardware_avr.md
+++ b/docs/es/hardware_avr.md
@ -67,7 +67,7 @@ El archivo `config.h` es donde configuras el hardware y el conjunto de caracter

 En la parte superior de `config.h` encontrarás ajustes relacionados con USB. Estos controlan la apariencia de tu teclado en el Sistema Operativo. Si no tienes una buena razón para cambiar debes dejar el `VENDOR_ID` como `0xFEED`. Para el `PRODUCT_ID` debes seleccionar un número que todavía no esté en uso.

-Cambia las líneas de `MANUFACTURER`, `PRODUCT`, y `DESCRIPTION` para reflejar con precisión tu teclado.
+Cambia las líneas de `MANUFACTURER` y `PRODUCT` para reflejar con precisión tu teclado.

 ```c
 #define VENDOR_ID       0xFEED
@ -75,7 +75,6 @@ Cambia las líneas de `MANUFACTURER`, `PRODUCT`, y `DESCRIPTION` para reflejar c
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    Tú
 #define PRODUCT         mi_teclado_fantastico
-#define DESCRIPTION     Un teclado personalizado
 ```

 ?> Windows y macOS mostrarán el `MANUFACTURER` y `PRODUCT` en la lista de dispositivos USB. `lsusb` en Linux toma estos de la lista mantenida por el [Repositorio de ID USB](http://www.linux-usb.org/usb-ids.html) por defecto. `lsusb -v` mostrará los valores reportados por el dispositivo, y también están presentes en los registros del núcleo después de conectarlo.
--- a/docs/feature_layers.md
+++ b/docs/feature_layers.md
@ -74,10 +74,9 @@ There are a number of functions (and variables) related to how you can use or ma
 | [`update_tri_layer(x, y, z)`](ref_functions.md#update_tri_layerx-y-z) | Checks if layers `x` and `y` are both on, and sets `z` based on that (on if both on, otherwise off). |
 | [`update_tri_layer_state(state, x, y, z)`](ref_functions.md#update_tri_layer_statestate-x-y-z) | Does the same as `update_tri_layer(x, y, z)`, but from `layer_state_set_*` functions. |

+In addition to the functions that you can call, there are a number of callback functions that get called every time the layer changes. This passes the layer state to the function, where it can be read or modified.

-In additional to the functions that you can call, there are a number of callback functions that get called every time the layer changes. This passed the layer state to the function, which can be read or modified.
-
-|Callbacks                                     |Description                                                                                    |
+|Callback                                             |Description                                                                             |
 |-----------------------------------------------------|----------------------------------------------------------------------------------------|
 | `layer_state_set_kb(layer_state_t state)`           | Callback for layer functions, for keyboard.                                            |
 | `layer_state_set_user(layer_state_t state)`         | Callback for layer functions, for users.                                               |
@ -86,9 +85,9 @@ In additional to the functions that you can call, there are a number of callback

 ?> For additional details on how you can use these callbacks, check out the [Layer Change Code](custom_quantum_functions.md#layer-change-code) document.

-|Check functions                                                  |Description                                                                   |
-|-------------------------------------------|------------------------------------------------------------------------------|
-| `layer_state_cmp(cmp_layer_state, layer)` | This checks the `cmp_layer_state` to see if the specific `layer` is enabled. This is meant for use with the layer callbacks. |
-| `layer_state_is(layer)`                   | This checks the layer state to see if the specific `layer` is enabled. (calls `layer_state_cmp` for the global layer state). |
+It is also possible to check the state of a particular layer using the following functions and macros.

-!> There is `IS_LAYER_ON(layer)` as well, however the `layer_state_cmp` function has some additional handling to ensure that on layer 0 that it returns the correct value. Otherwise, if you check to see if layer 0 is on, you may get an incorrect value returned. 
+|Function                         |Description                                                                                      |Aliases
+|---------------------------------|-------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------|
+| `layer_state_is(layer)`         | Checks if the specified `layer` is enabled globally.                                            | `IS_LAYER_ON(layer)`, `IS_LAYER_OFF(layer)`                           |
+| `layer_state_cmp(state, layer)` | Checks `state` to see if the specified `layer` is enabled. Intended for use in layer callbacks. | `IS_LAYER_ON_STATE(state, layer)`, `IS_LAYER_OFF_STATE(state, layer)` |
--- a/docs/feature_mouse_keys.md
+++ b/docs/feature_mouse_keys.md
@ -39,10 +39,11 @@ In your keymap you can use the following keycodes to map key presses to mouse ac

 ## Configuring mouse keys

-Mouse keys supports two different modes to move the cursor:
+Mouse keys supports three different modes to move the cursor:

 * **Accelerated (default):** Holding movement keys accelerates the cursor until it reaches its maximum speed.
 * **Constant:** Holding movement keys moves the cursor at constant speeds.
+* **Combined:** Holding movement keys accelerates the cursor until it reaches its maximum speed, but holding acceleration and movement keys simultaneously moves the cursor at constant speeds.

 The same principle applies to scrolling.

@ -120,3 +121,22 @@ Use the following settings if you want to adjust cursor movement or scrolling:
 |`MK_W_INTERVAL_1`    |120          |Time between scroll steps (`KC_ACL1`)      |
 |`MK_W_OFFSET_2`      |1            |Scroll steps per scroll action (`KC_ACL2`) |
 |`MK_W_INTERVAL_2`    |20           |Time between scroll steps (`KC_ACL2`)      |
+
+### Combined mode
+
+This mode functions like **Accelerated** mode, however, you can hold `KC_ACL0`, `KC_ACL1` and `KC_ACL2`
+to momentarily (while held) set the cursor and scroll speeds to constant speeds. When no acceleration
+keys are held, this mode is identical to **Accelerated** mode, and can be modified using all of the
+relevant settings.
+
+* **KC_ACL0:** This acceleration sets your cursor to the slowest possible speed. This is useful for very
+small and detailed movements of the cursor.
+* **KC_ACL1:** This acceleration sets your cursor to half the maximum (user defined) speed.
+* **KC_ACL2:** This acceleration sets your cursor to the maximum (computer defined) speed. This is
+useful for moving the cursor large distances without much accuracy.
+
+To use constant speed mode, you must at least define `MK_COMBINED` in your keymap’s `config.h` file:
+
+```c
+#define MK_COMBINED
+```
--- a/docs/feature_oled_driver.md
+++ b/docs/feature_oled_driver.md
@ -247,6 +247,10 @@ void oled_write_raw_byte(const char data, uint16_t index);
 // Writes a PROGMEM string to the buffer at current cursor position
 void oled_write_raw_P(const char *data, uint16_t size);

+// Sets a specific pixel on or off
+// Coordinates start at top-left and go right and down for positive x and y
+void oled_write_pixel(uint8_t x, uint8_t y, bool on);
+
 // Can be used to manually turn on the screen if it is off
 // Returns true if the screen was on or turns on
 bool oled_on(void);
--- a/docs/hardware_avr.md
+++ b/docs/hardware_avr.md
@ -67,7 +67,7 @@ The `config.h` file is where you configure the hardware and feature set for your

 At the top of the `config.h` you'll find USB related settings. These control how your keyboard appears to the Operating System. If you don't have a good reason to change you should leave the `VENDOR_ID` as `0xFEED`. For the `PRODUCT_ID` you should pick a number that is not yet in use.

-Do change the `MANUFACTURER`, `PRODUCT`, and `DESCRIPTION` lines to accurately reflect your keyboard.
+Do change the `MANUFACTURER` and `PRODUCT` lines to accurately reflect your keyboard.

 ```c
 #define VENDOR_ID       0xFEED
@ -75,7 +75,6 @@ Do change the `MANUFACTURER`, `PRODUCT`, and `DESCRIPTION` lines to accurately r
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    You
 #define PRODUCT         my_awesome_keyboard
-#define DESCRIPTION     A custom keyboard
 ```

 ?> Windows and macOS will display the `MANUFACTURER` and `PRODUCT` in the list of USB devices. `lsusb` on Linux instead takes these from the list maintained by the [USB ID Repository](http://www.linux-usb.org/usb-ids.html) by default. `lsusb -v` will show the values reported by the device, and they are also present in kernel logs after plugging it in.
--- a/docs/isp_flashing_guide.md
+++ b/docs/isp_flashing_guide.md
@ -141,7 +141,9 @@ To do this manually:

 ?> It's possible to use other bootloaders here in the same way, but __you need a bootloader__, otherwise you'll have to use ISP again to write new firmware to your keyboard.

-To do this the easy way, you can flash the board using the `:production` target when compiling.  This compiles the firmware, then compiles the QMK DFU bootloader, and then creates a combined image.  Once this is done, you'll see three files: 
+#### Create QMK DFU Bootloader and Production images
+
+You can create the firmware, the QMK DFU Bootloader and the production firmware images for the board using the `:production` target when compiling.  Once this is done, you'll see three files: 
 * `<keyboard>_<keymap>.hex`
 * `<keyboard>_<keymap>_bootloader.hex`
 * `<keyboard>_<keymap>_production.hex`
@ -236,12 +238,12 @@ For Caterina on the `atmega32u4`, these are the fuse settings that you want:
 | Fuse     | Setting|
 |----------|--------|
 | Low      | `0xFF` |
-| High     | `0xD9` |
-| Extended | `0xC3` |
+| High     | `0xD8` |
+| Extended | `0xCB` |

-To set this add `-U lfuse:w:0xFF:m -U hfuse:w:0xD8:m -U efuse:w:0xC3:m` to your command.  So the final command should look something like: 
+To set this add `-U lfuse:w:0xFF:m -U hfuse:w:0xD8:m -U efuse:w:0xCB:m` to your command.  So the final command should look something like: 

-    avrdude -c avrisp -P COM3 -p atmega32u4 -U flash:w:main.hex:i -U lfuse:w:0xFF:m -U hfuse:w:0xD8:m -U efuse:w:0xC3:m
+    avrdude -c avrisp -P COM3 -p atmega32u4 -U flash:w:main.hex:i -U lfuse:w:0xFF:m -U hfuse:w:0xD8:m -U efuse:w:0xCB:m


 If you are using a different controller or want different configuration, you can use [this AVR Fuse Calculator](http://www.engbedded.com/fusecalc/) to find a better value for you.
--- a/docs/ja/_summary.md
+++ b/docs/ja/_summary.md
@ -6,6 +6,7 @@
  * [テストとデバッグ](ja/newbs_testing_debugging.md)
  * [手助けを得る/サポート](ja/support.md)
  * [他のリソース](ja/newbs_learn_more_resources.md)
+  * [シラバス](ja/syllabus.md)

 * FAQ
  * [一般的な FAQ](ja/faq_general.md)
@ -33,7 +34,9 @@
    * [機能のカスタマイズ](ja/custom_quantum_functions.md)
    * [Zadig を使ったドライバのインストール](ja/driver_installation_zadig.md)
    * [キーマップの概要](ja/keymap.md)
-    * [Vagrant のガイド](ja/getting_started_vagrant.md)
+    * 開発環境
+      * [Docker のガイド](ja/getting_started_docker.md)
+      * [Vagrant のガイド](ja/getting_started_vagrant.md)
    * 書き込み
      * [書き込み](ja/flashing.md)
      * [ATmega32A の書き込み (ps2avrgb)](ja/flashing_bootloadhid.md)
@ -52,6 +55,7 @@
  * 単純なキーコード
    * [完全なリスト](ja/keycodes.md)
    * [基本的なキーコード](ja/keycodes_basic.md)
+    * [言語固有のキーコード](ja/reference_keymap_extras.md)
    * [修飾キー](ja/feature_advanced_keycodes.md)
    * [Quantum キーコード](ja/quantum_keycodes.md)

@ -72,9 +76,10 @@
    * [デバウンス API](ja/feature_debounce_type.md)
    * [キーロック](ja/feature_key_lock.md)
    * [レイヤー](ja/feature_layers.md)
-    * [One Shot Keys](ja/one_shot_keys.md)
+    * [ワンショットキー](ja/one_shot_keys.md)
    * [ポインティング デバイス](ja/feature_pointing_device.md)
-    * [Swap Hands](ja/feature_swap_hands.md)
+    * [ロー HID](ja/feature_rawhid.md)
+    * [スワップハンド](ja/feature_swap_hands.md)
    * [タップダンス](ja/feature_tap_dance.md)
    * [タップホールド設定](ja/tap_hold.md)
    * [ターミナル](ja/feature_terminal.md)
@ -101,7 +106,7 @@
    * [Proton C 規約](ja/proton_c_conversion.md)
    * [PS/2 マウス](ja/feature_ps2_mouse.md)
    * [分割キーボード](ja/feature_split_keyboard.md)
-    * [Stenography](ja/feature_stenography.md)
+    * [速記](ja/feature_stenography.md)
    * [感熱式プリンタ](ja/feature_thermal_printer.md)
    * [Velocikey](ja/feature_velocikey.md)

@ -110,6 +115,7 @@
    * [概要](ja/breaking_changes.md)
    * [プルリクエストにフラグが付けられた](ja/breaking_changes_instructions.md)
    * 履歴
+      * [2020年5月30日](ja/ChangeLog/20200530.md)
      * [2020年2月29日](ja/ChangeLog/20200229.md)
      * [2019年8月30日](ja/ChangeLog/20190830.md)

@ -124,6 +130,7 @@
      * [SPI ドライバ](ja/spi_driver.md)
      * [WS2812 ドライバ](ja/ws2812_driver.md)
      * [EEPROM ドライバ](ja/eeprom_driver.md)
+      * [シリアル ドライバ](ja/serial_driver.md)
    * [GPIO コントロール](ja/internals_gpio_control.md)
    * [キーボード ガイドライン](ja/hardware_keyboard_guidelines.md)

@ -136,6 +143,11 @@
      * [開発環境](ja/api_development_environment.md)
      * [アーキテクチャの概要](ja/api_development_overview.md)

+  * ハードウェアプラットフォーム開発
+    * Arm/ChibiOS
+      * [MCU の選択](ja/platformdev_selecting_arm_mcu.md)
+      * [早期初期化](ja/platformdev_chibios_earlyinit.md)
+
  * QMK Reference
    * [QMK への貢献](ja/contributing.md)
    * [QMK ドキュメントの翻訳](ja/translating.md)
@ -155,9 +167,9 @@

  * QMK の内部詳細(作成中)
    * [定義](ja/internals_defines.md)
-    * [Input Callback Reg](ja/internals_input_callback_reg.md)
+    * [入力コールバック登録](ja/internals_input_callback_reg.md)
    * [Midi デバイス](ja/internals_midi_device.md)
    * [Midi デバイスのセットアップ手順](ja/internals_midi_device_setup_process.md)
    * [Midi ユーティリティ](ja/internals_midi_util.md)
-    * [Send Functions](ja/internals_send_functions.md)
+    * [Midi 送信関数](ja/internals_send_functions.md)
    * [Sysex Tools](ja/internals_sysex_tools.md)
--- a/docs/ja/cli_development.md
+++ b/docs/ja/cli_development.md
@ -0,0 +1,223 @@
+# QMK CLI 開発
+
+<!---
+  original document: 0.9.19:docs/cli_development.md
+  git diff 0.9.19 HEAD -- docs/cli_development.md | cat
+-->
+
+このドキュメントは、新しい `qmk`  サブコマンドを書きたい開発者に役立つ情報が含まれています。
+
+# 概要
+
+QMK CLI は git で有名になったサブコマンドパターンを使って動作します。メインの `qmk` スクリプトは単に環境をセットアップし、実行する正しいエントリポイントを選択するためにあります。各サブコマンドは、何らかのアクションを実行しシェルのリターンコード、または None を返すエントリーポイント (`@cli.subcommand()` で修飾されます)を備えた自己完結型のモジュールです。
+
+## 開発者モード:
+
+キーボードを保守、あるいは QMK に貢献したい場合は、CLI の「開発者」モードを有効にすることができます:
+
+`qmk config user.developer=True`
+
+これにより利用可能な全てのサブコマンドが表示されます。
+**注意:** 追加で必要なものをインストールする必要があります:
+```bash
+python3 -m pip install -r requirements-dev.txt
+```
+
+# サブコマンド
+
+[MILC](https://github.com/clueboard/milc) は、`qmk` が引数の解析、設定、ログ、およびほかの多くの機能を処理するために使用する CLI フレームワークです。グルーコードを書くために時間を無駄にすることなく、ツールの作成に集中できます。
+
+ローカル CLI 内のサブコマンドは、常に `qmk_firmware/lib/python/qmk/cli` で見つかります。
+
+サブコマンドの例を見てみましょう。これは `lib/python/qmk/cli/hello.py` です:
+
+```python
+"""QMK Python Hello World
+
+This is an example QMK CLI script.
+"""
+from milc import cli
+
+
+@cli.argument('-n', '--name', default='World', help='Name to greet.')
+@cli.subcommand('QMK Hello World.')
+def hello(cli):
+    """Log a friendly greeting.
+    """
+    cli.log.info('Hello, %s!', cli.config.hello.name)
+```
+
+最初に `milc` から `cli` をインポートします。これが、ユーザとやり取りをし、スクリプトの挙動を制御する方法です。`@cli.argument()` を使って、コマンドラインフラグ `--name` を定義します。これは、ユーザが設定できる `hello.name` (そして対応する `user.name`) という名前の設定変数も作成し、引数を指定する必要が無くなります。`cli.subcommand()` デコレータは、この関数をサブコマンドとして指定します。サブコマンドの名前は関数の名前から取られます。
+
+関数の中に入ると、典型的な "Hello, World!" プログラムが見つかります。`cli.log` を使って、基礎となる [ロガーオブジェクト](https://docs.python.org/3.6/library/logging.html#logger-objects) にアクセスし、その挙動はユーザが制御できます。またユーザが指定した名前の値に `cli.config.hello.name` でアクセスします。`cli.config.hello.name` の値は、ユーザが指定した `--name` 引数を調べることで決定されます。指定されていない場合、`qmk.ini` 設定ファイルの中の値が使われ、どちらも指定されていない場合は `cli.argument()`  デコレータで指定されたデフォルトが代用されます。
+
+# ユーザとの対話処理
+
+MILC と QMK CLI にはユーザとやり取りするための幾つかの便利なツールがあります。これらの標準ツールを使うと、テキストに色を付けて対話し易くし、ユーザはその情報をいつどのように表示および保存するかを制御することができます。
+
+## テキストの表示
+
+サブコマンド内でテキストを出力するための2つの主な方法があります- `cli.log` と `cli.echo()`。それらは似た方法で動作しますが、ほとんどの一般的な目的の出力には `cli.log.info()` を使うことをお勧めします。
+
+特別なトークンを使用してテキストを色付けし、プログラムの出力を理解しやすくすることができます。以下の[テキストの色付け](#colorizing-text)を見てください。
+
+これらの両方の方法は python の [printf 形式の文字列書式化](https://docs.python.org/3.6/library/stdtypes.html#old-string-formatting) を使った組み込みの文字列書式化をサポートします。テキスト文字列内で`%s` と `%d` のようなトークンを使い、引数で値を渡すことができます。例として、上記の Hello、World プログラムを見てください。
+
+書式演算子 (`%`) を直接使わないでください、常に引数で値を渡します。
+
+### ログ (`cli.log`)
+
+`cli.log` オブジェクトは[ロガーオブジェクト](https://docs.python.org/3.6/library/logging.html#logger-objects)へのアクセスを与えます。ログ出力を設定し、ユーザに各ログレベルの素敵な絵文字(またはターミナルが unicode をサポートしない場合はログレベル名)を表示します。このようにして、ユーザは何か問題が発生した時に最も重要なメッセージを一目で確認することができます。
+
+デフォルトのログレベルは `INFO` です。ユーザが `qmk -v <subcommand>` を実行すると、デフォルトのログレベルは `DEBUG` に設定されます。
+
+| 関数 | 絵文字 |
+|----------|-------|
+| cli.log.critical | `{bg_red}{fg_white}¬_¬{style_reset_all}` |
+| cli.log.error | `{fg_red}☒{style_reset_all}` |
+| cli.log.warning | `{fg_yellow}⚠{style_reset_all}` |
+| cli.log.info | `{fg_blue}Ψ{style_reset_all}` |
+| cli.log.debug | `{fg_cyan}☐{style_reset_all}` |
+| cli.log.notset | `{style_reset_all}¯\\_(o_o)_/¯` |
+
+### 出力 (`cli.echo`)
+
+場合によっては単にログシステムの外部でテキストを出力する必要があります。これは、固定データを出力したり、ログに記録してはいけない何かを書きだす場合に適しています。ほとんどの場合、`cli.echo` よりも `cli.log.info()` を選ぶべきです。
+
+### テキストの色付け
+
+テキスト内に色トークンを含めることで、テキストの出力を色付けすることができます。情報を伝えるためではなく、強調するために色を使います。ユーザは色を無効にできることを覚えておいてください。色を無効にした場合でもサブコマンドは引き続き使えるようにしてください。
+
+背景色を設定するのは、あなたがやっていることに不可欠ではない限り、通常は避けるべきです。ユーザは、ターミナルの色に関しては多くの好みを持つため、あなたは黒と白のどちらの背景に対してもうまく機能する色を選択する必要があることを覚えておいてください。
+
+'fg' という接頭辞の付いた色は、前景(テキスト)色に影響します。'bg' という接頭辞の付いた色は、背景色に影響します。
+
+| 色 | 背景 | 拡張背景 | 前景 | 拡張前景 |
+|-------|------------|---------------------|------------|--------------------|
+| 黒 | {bg_black} | {bg_lightblack_ex} | {fg_black} | {fg_lightblack_ex} |
+| 青 | {bg_blue} | {bg_lightblue_ex} | {fg_blue} | {fg_lightblue_ex} |
+| シアン | {bg_cyan} | {bg_lightcyan_ex} | {fg_cyan} | {fg_lightcyan_ex} |
+| 緑 | {bg_green} | {bg_lightgreen_ex} | {fg_green} | {fg_lightgreen_ex} |
+| マゼンタ | {bg_magenta} | {bg_lightmagenta_ex} | {fg_magenta} | {fg_lightmagenta_ex} |
+| 赤 | {bg_red} | {bg_lightred_ex} | {fg_red} | {fg_lightred_ex} |
+| 白 | {bg_white} | {bg_lightwhite_ex} | {fg_white} | {fg_lightwhite_ex} |
+| 黄 | {bg_yellow} | {bg_lightyellow_ex} | {fg_yellow} | {fg_lightyellow_ex} |
+
+ANSI 出力の挙動を変更するために使うことができる制御シーケンスもあります。
+
+| 制御シーケンス | 説明 |
+|-------------------|-------------|
+| {style_bright} | テキストを明るくする |
+| {style_dim} | テキストを暗くする |
+| {style_normal} | テキストを通常にする (`{style_bright}` または `{style_dim}` のどちらでもない) |
+| {style_reset_all} | 全てのテキストの属性をデフォルトに再設定する(これは自動的に全ての文字列の最後に自動的に追加されます。) |
+| {bg_reset} | 背景色をユーザのデフォルトに再設定します。 |
+| {fg_reset} | 背景色をユーザのデフォルトに再設定します。 |
+
+# 引数と設定
+
+QMK は引数の解析と設定の詳細をあなたの代わりに処理します。新しい引数を追加すると、サブコマンドの名前と引数の長い名前に基づいて設定ツリーに自動的に組み込まれます。属性形式のアクセス (`cli.config.<subcommand>.<argument>`) あるいは辞書形式のアクセス (`cli.config['<subcommand>']['<argument>']`) を使って、`cli.config` 内のこの設定にアクセスすることができます。
+
+内部では、QMK は [設定ファイルのパーサ](https://docs.python.org/3/library/configparser.html) を使って設定を格納します。これにより、人間が編集可能な方法で設定を表す簡単で分かり易い方法を提供します。この設定へのアクセスをラップして、設定ファイルのパーサーが通常持たない幾つかの機能を提供しています。
+
+## 設定値の読み込み
+
+通常期待される全ての方法で `cli.config` とやり取りすることができます。例えば、`qmk compile` コマンドは `cli.config.compile.keyboard` からキーボード名を取得します。値がコマンドライン、環境変数あるいは設定ファイルからきたものであるかどうかを知る必要はありません。
+
+繰り返しもサポートされます:
+
+```
+for section in cli.config:
+    for key in cli.config[section]:
+        cli.log.info('%s.%s: %s', section, key, cli.config[section][key])
+```
+
+## 設定値の設定
+
+通常の方法で設定値を設定することができます。
+
+辞書形式:
+
+```
+cli.config['<section>']['<key>'] = <value>
+```
+
+属性形式:
+
+```
+cli.config.<section>.<key> = <value>
+```
+
+## 設定値の削除
+
+通常の方法で設定値を削除することができます。
+
+辞書形式:
+
+```
+del(cli.config['<section>']['<key>'])
+```
+
+属性形式:
+
+```
+del(cli.config.<section>.<key>)
+```
+
+## 設定ファイルの書き方
+
+設定は変更しても書き出されません。ほとんどのコマンドでこれをする必要はありません。ユーザに `qmk config` を使って設定を慎重に変更させることをお勧めします。
+
+設定を書き出すために `cli.save_config()` を使うことができます。
+
+## 設定からの引数の除外
+
+一部の引数は設定ファイルに反映すべきではありません。これらは引数を作成する時に `arg_only=True` を追加することで除外することができます。
+
+例:
+
+```
+@cli.argument('-o', '--output', arg_only=True, help='File to write to')
+@cli.argument('filename', arg_only=True, help='Configurator JSON file')
+@cli.subcommand('Create a keymap.c from a QMK Configurator export.')
+def json_keymap(cli):
+    pass
+```
+
+`cli.args` を使ってのみこれらの引数にアクセスすることができます。例えば:
+
+```
+cli.log.info('Reading from %s and writing to %s', cli.args.filename, cli.args.output)
+```
+
+# テスト、リントおよびフォーマット
+
+nose2、flake8 および yapf を使ってコードをテスト、リントおよびフォーマットします。これらのテストを実行するために `pytest` と `pyformat` サブコマンドを使うことができます。
+
+### テストとリント
+
+    qmk pytest
+
+### フォーマット
+
+    qmk pyformat
+
+## フォーマットの詳細
+
+[yapf](https://github.com/google/yapf) を使ってコードを自動的にフォーマットします。フォーマットの設定は `setup.cfg` の `[yapf]` セクションにあります。
+
+?> ヒント- 多くのエディタは yapf をプラグインとして使って、入力したコードを自動的にフォーマットすることができます。
+
+## テストの詳細
+
+テストは `lib/python/qmk/tests/` にあります。このディレクトリに単体テストと統合テストの両方があります。コードの単体テストと統合テストの両方を書いてほしいですが、一方のみ書く場合は統合テストを優先してください。
+
+PR にテストの包括的なセットが含まれない場合は、次のようなコメントをコードに追加して、他の人が手助けできるようにしてください:
+
+    # TODO(unassigned/<your_github_username>): Write <unit|integration> tests
+
+[nose2](https://nose2.readthedocs.io/en/latest/getting_started.html) を使ってテストを実行します。テスト関数でできることの詳細については、nose2  のドキュメントを参照してください。
+
+## リントの詳細
+
+flake8 を使ってコードをリントします。PR を開く前に、コードは flake8 をパスしなければなりません。これは `qmk pytest` を実行するときにチェックされ、PR を登録したときに CI によってチェックされます。
--- a/docs/ja/config_options.md
+++ b/docs/ja/config_options.md
@ -1,8 +1,8 @@
 # QMK の設定

 <!---
-  original document: 0.8.62:docs/config_options.md
-  git diff 0.8.62 HEAD -- docs/config_options.md | cat
+  original document: 0.9.43:docs/config_options.md
+  git diff 0.9.43 HEAD -- docs/config_options.md | cat
 -->

 QMK はほぼ無制限に設定可能です。可能なところはいかなるところでも、やりすぎな程、ユーザーがコードサイズを犠牲にしてでも彼らのキーボードをカスタマイズをすることを許しています。ただし、このレベルの柔軟性により設定が困難になります。
@ -48,8 +48,6 @@ QMK での全ての利用可能な設定にはデフォルトがあります。
  * 一般的に、誰もしくはどのブランドがボードを作成したか
 * `#define PRODUCT Board`
  * キーボードの名前
-* `#define DESCRIPTION a keyboard`
-  * キーボードの簡単な説明
 * `#define MATRIX_ROWS 5`
  * キーボードのマトリックスの行の数
 * `#define MATRIX_COLS 15`
@ -120,9 +118,9 @@ QMK での全ての利用可能な設定にはデフォルトがあります。
 * `#define NO_ACTION_ONESHOT`
  * ワンショットモディファイアを無効にします
 * `#define NO_ACTION_MACRO`
-  * 古い形式のマクロ処理を無効にします: MACRO() & action_get_macro
+  * `MACRO()`、`action_get_macro()` _(非推奨)_ を使う古い形式のマクロ処理を無効にします
 * `#define NO_ACTION_FUNCTION`
-  * fn_actions 配列(非推奨)からの action_function() の呼び出しを無効にします 
+  * `fn_actions`、`action_function()` _(非推奨)_ を使う古い形式の関数処理を無効にします

 ## 有効にできる機能

@ -189,7 +187,14 @@ QMK での全ての利用可能な設定にはデフォルトがあります。
 * `#define RGBLIGHT_ANIMATIONS`
  * RGB アニメーションを実行します
 * `#define RGBLIGHT_LAYERS`
-  * オンとオフを切り替えることができる [ライトレイヤー](ja/feature_rgblight.md) を定義できます。現在のキーボードレイヤーまたは Caps Lock 状態を表示するのに最適です。
+  * オンとオフを切り替えることができる [ライトレイヤー](ja/feature_rgblight.md?id=lighting-layers) を定義できます。現在のキーボードレイヤーまたは Caps Lock 状態を表示するのに最適です。
+* `#define RGBLIGHT_MAX_LAYERS`
+  * デフォルトは8です。もしさらに [ライトレイヤー](ja/feature_rgblight.md?id=lighting-layers) が必要であれば、32まで拡張できます。
+  * メモ: 最大値を大きくするとファームウェアサイズが大きくなり、分割キーボードで同期が遅くなります。
+* `#define RGBLIGHT_LAYER_BLINK`
+  * 指定されたミリ秒の間、ライトレイヤーを [点滅](ja/feature_rgblight.md?id=lighting-layer-blink) する機能を追加します(例えば、アクションを確認するため)。
+* `#define RGBLIGHT_LAYERS_OVERRIDE_RGB_OFF`
+  * 定義されている場合、RGB ライトがオフになっている場合でも [ライトレイヤー](ja/feature_rgblight?id=overriding-rgb-lighting-onoff-status) が表示されます。
 * `#define RGBLED_NUM 12`
  * LED の数
 * `#define RGBLIGHT_SPLIT`
@ -241,7 +246,10 @@ QMK での全ての利用可能な設定にはデフォルトがあります。
 * `#define SPLIT_HAND_PIN B7`
  * high/low ピンを使って左右を決定します。low = 右手、high = 左手。`B7` を使っているピンに置き換えます。これはオプションで、`SPLIT_HAND_PIN` が未定義のままである場合、EE_HANDS メソッドまたは標準の Let's Splitが使っている MASTER_LEFT / MASTER_RIGHT 定義をまだ使うことができます。

-* `#define EE_HANDS` (`SPLIT_HAND_PIN` が定義されていない場合のみ動作します)
+* `#define SPLIT_HAND_MATRIX_GRID <out_pin>,<in_pin>`
+  * 左右はキーマトリックスのキースイッチが存在しない交点を使って決定されます。通常、この交点が短絡している(ローレベル)のときに左側と見なされます。もし `#define SPLIT_HAND_MATRIX_GRID_LOW_IS_RIGHT` が定義されている場合は、ローレベルの時に右側と決定されます。
+
+* `#define EE_HANDS` (`SPLIT_HAND_PIN` と `SPLIT_HAND_MATRIX_GRID` が定義されていない場合のみ動作します)
  * `eeprom-lefthand.eep`/`eeprom-righthand.eep` がそれぞれの半分に書き込まれた後で、EEPROM 内に格納されている左右の設定の値を読み込みます。

 * `#define MASTER_RIGHT`
@ -315,7 +323,8 @@ QMK での全ての利用可能な設定にはデフォルトがあります。
 * `LAYOUTS`
  * このキーボードがサポートする[レイアウト](ja/feature_layouts.md)のリスト
 * `LINK_TIME_OPTIMIZATION_ENABLE`
-  * キーボードをコンパイルする時に、Link Time Optimization (`LTO`) を有効にします。これは処理に時間が掛かりますが、コンパイルされたサイズを大幅に減らします (そして、ファームウェアが小さいため、追加の時間は分からないくらいです)。ただし、`LTO` が有効な場合、古いマクロと関数の機能が壊れるため、自動的にこれらの機能を無効にします。これは `NO_ACTION_MACRO` と `NO_ACTION_FUNCTION` を自動的に定義することで行われます。
+  * キーボードをコンパイルする時に、Link Time Optimization (LTO) を有効にします。これは処理に時間が掛かりますが、コンパイルされたサイズを大幅に減らします (そして、ファームウェアが小さいため、追加の時間は分からないくらいです)。
+ただし、LTO が有効な場合、古い TMK のマクロと関数の機能が壊れるため、自動的にこれらの機能を無効にします。これは `NO_ACTION_MACRO` と `NO_ACTION_FUNCTION` を自動的に定義することで行われます。(メモ: これは QMK の [マクロ](ja/feature_macros.md) と [レイヤー](ja/feature_layers.md) には影響を与えません。)
 * `LTO_ENABLE`
  * LINK_TIME_OPTIMIZATION_ENABLE と同じ意味です。`LINK_TIME_OPTIMIZATION_ENABLE` の代わりに `LTO_ENABLE` を使うことができます。

--- a/docs/ja/custom_quantum_functions.md
+++ b/docs/ja/custom_quantum_functions.md
@ -1,8 +1,8 @@
 # キーボードの挙動をカスタマイズする方法

 <!---
-  original document: 0.8.62:docs/custom_quantum_functions.md
-  git diff 0.8.62 HEAD -- docs/custom_quantum_functions.md | cat
+  original document: 0.9.43:docs/custom_quantum_functions.md
+  git diff 0.9.43 HEAD -- docs/custom_quantum_functions.md | cat
 -->

 多くの人にとって、カスタムキーボードはボタンの押下をコンピュータに送信するだけではありません。単純なボタンの押下やマクロよりも複雑なことを実行できるようにしたいでしょう。QMK にはコードを挿入したり、機能を上書きしたり、様々な状況でキーボードの挙動をカスタマイズできるフックがあります。
@ -346,6 +346,11 @@ layer_state_t layer_state_set_user(layer_state_t state) {
  return state;
 }
 ```
+
+特定のレイヤーの状態を確認するには、 `IS_LAYER_ON_STATE(state, layer)` と `IS_LAYER_OFF_STATE(state, layer)` マクロを使います。
+
+`layer_state_set_*` 関数の外では、グローバルなレイヤー状態を確認するために `IS_LAYER_ON(layer)` と `IS_LAYER_OFF(layer)` マクロを使えます。
+
 ### `layer_state_set_*` 関数のドキュメント

 * キーボード/リビジョン: `layer_state_t layer_state_set_kb(layer_state_t state)`
@ -451,7 +456,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
                layer_state_set(layer_state);   // すぐにレイヤーの色を更新します
            }
        }
-        return false; break;
+        return false;
    case RGB_MODE_FORWARD ... RGB_MODE_GRADIENT: // 任意の RGB コード に対して(quantum_keycodes.h を見てください。400行目参照)
        if (record->event.pressed) { // これはレイヤー表示を無効にします。これを変更する場合は、無効にしたいだろうため。
            if (user_config.rgb_layer_change) {        // 有効な場合のみ
@ -488,56 +493,3 @@ void eeconfig_init_user(void) {  // EEPROM がリセットされます！
 * キーマップ: `void eeconfig_init_user(void)`、`uint32_t eeconfig_read_user(void)` および `void eeconfig_update_user(uint32_t val)`

 `val` は EEPROM に書き込みたいデータの値です。`eeconfig_read_*` 関数は EEPROM から32ビット(DWORD) 値を返します。
-
-# カスタムタッピング期間
-
-デフォルトでは、タッピング期間と(`IGNORE_MOD_TAP_INTERRUPT` のような)関連オプションはグローバルに設定されていて、キーでは設定することができません。ほとんどのユーザにとって、これは全然問題ありません。しかし、場合によっては、`LT` キーとは異なるタイムアウトによって、デュアルファンクションキーが大幅に改善されます。なぜなら、一部のキーは他のキーよりも押し続けやすいためです。それぞれにカスタムキーコードを使う代わりに、キーごとに設定可能なタイムアウトの挙動を設定できます。
-
-キーごとのタイムアウトの挙動を制御するための2つの設定可能なオプションがあります:
-
- `TAPPING_TERM_PER_KEY`
- `IGNORE_MOD_TAP_INTERRUPT_PER_KEY`
-
-必要な機能ごとに、`config.h` に `#define` 行を追加する必要があります。
-
-```
-#define TAPPING_TERM_PER_KEY
-#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY
-```
-
-
-## `get_tapping_term` の実装例
-
-キーコードに基づいて `TAPPING_TERM` を変更するには、次のようなものを `keymap.c` ファイルに追加します:
-
-```c
-uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) {
-  switch (keycode) {
-    case SFT_T(KC_SPC):
-      return TAPPING_TERM + 1250;
-    case LT(1, KC_GRV):
-      return 130;
-    default:
-      return TAPPING_TERM;
-  }
-}
-```
-
-## `get_ignore_mod_tap_interrupt` の実装例
-
-キーコードに基づいて `IGNORE_MOD_TAP_INTERRUPT` の値を変更するには、次のようなものを `keymap.c` ファイルに追加します:
-
-```c
-bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record) {
-  switch (keycode) {
-    case SFT_T(KC_SPC):
-      return true;
-    default:
-      return false;
-  }
-}
-```
-
-## `get_tapping_term` / `get_ignore_mod_tap_interrupt` 関数のドキュメント
-
-ここにある他の多くの関数とは異なり、quantum あるいはキーボードレベルの関数を持つ必要はありません (または理由さえありません)。ここではユーザレベルの関数だけが有用なため、そのようにマークする必要はありません。
--- a/docs/ja/driver_installation_zadig.md
+++ b/docs/ja/driver_installation_zadig.md
@ -1,8 +1,8 @@
 # Zadig を使ったブートローダドライバのインストール

 <!---
-  original document: 0.9.0:docs/driver_installation_zadig.md
-  git diff 0.9.0 HEAD -- docs/driver_installation_zadig.md | cat
+  original document: 0.9.43:docs/driver_installation_zadig.md
+  git diff 0.9.43 HEAD -- docs/driver_installation_zadig.md | cat
 -->

 QMK はホストにたいして通常の HID キーボードデバイスとして振る舞うため特別なドライバは必要ありません。しかし、Windows でのキーボードへの書き込みは、多くの場合、キーボードをリセットした時に現れるブートローダデバイスで*行います*。
@ -28,7 +28,7 @@ Zadig は自動的にブートローダデバイスを検知します。**Option

 !> Zadig が `HidUsb` ドライバを使用する1つ以上のデバイスを表示する場合、キーボードはおそらくブートローダモードではありません。矢印はオレンジ色になり、システムドライバの変更を確認するように求められます。この場合、続行**しないでください**！

-矢印が緑色で表示されたら、ドライバを選択し、**Install Driver** をクリックします。`libusb-win32` ドライバは通常 AVR で動作し、`WinUSB`は ARM で動作しますが、それでもキーボードに書き込みできない場合は、リストから異なるドライバをインストールしてみてください。msys2 を使ってコマンドライン経由で USBaspLoader デバイスに書き込むには、`libusbk` ドライバがお勧めです。そうではなく書き込みに QMK Toolbox を使っている場合は `libusb-win32` がうまく動作します。
+矢印が緑色で表示されたら、ドライバを選択し、**Install Driver** をクリックします。`libusb-win32` ドライバは通常 AVR で動作し、`WinUSB`は ARM で動作しますが、それでもキーボードに書き込みできない場合は、リストから異なるドライバをインストールしてみてください。USBAspLoader デバイスは `libusbK` ドライバを使わなければなりません。

 ![ブートローダドライバが正常にインストールされた Zadig](https://i.imgur.com/b8VgXzx.png)

--- a/docs/ja/faq_build.md
+++ b/docs/ja/faq_build.md
@ -1,8 +1,8 @@
 # よくあるビルドの質問

 <!---
-  original document: 0.9.10:docs/faq_build.md
-  git diff 0.9.10 HEAD -- docs/faq_build.md | cat
+  original document: 0.9.43:docs/faq_build.md
+  git diff 0.9.43 HEAD -- docs/faq_build.md | cat
 -->

 このページは QMK のビルドに関する質問を説明します。まだビルドをしていない場合は、[ビルド環境のセットアップ](ja/getting_started_build_tools.md) および [Make 手順](ja/getting_started_make_guide.md)ガイドを読むべきです。
@ -57,7 +57,7 @@ SUBSYSTEMS=="usb", ATTRS{idVendor}=="1b4f", ATTRS{idProduct}=="9203", TAG+="uacc

 **注意:** 古い(1.12以前の) ModemManager では、フィルタリングは厳密なモードではない場合にのみ動作し、以下のコマンドはその設定を更新することができます。
 ```console
-sudo sed -i 's/--filter-policy=strict/--filter-policy=default/' /lib/systemd/system/ModemManager.service
+printf '[Service]\nExecStart=\nExecStart=/usr/sbin/ModemManager --filter-policy=default' | sudo tee /etc/systemd/system/ModemManager.service.d/policy.conf
 sudo systemctl daemon-reload
 sudo systemctl restart ModemManager
 ```
--- a/docs/ja/feature_backlight.md
+++ b/docs/ja/feature_backlight.md
@ -1,253 +1,224 @@
-# バックライト
+# バックライト :id=backlighting

 <!---
-  original document: 0.9.10:docs/feature_backlight.md
-  git diff 0.9.10 HEAD -- docs/feature_backlight.md | cat
+  original document: 0.9.44:docs/feature_backlight.md
+  git diff 0.9.44 HEAD -- docs/feature_backlight.md | cat
 -->

 多くのキーボードは、キースイッチを貫通して配置されたり、キースイッチの下に配置された個々の LED によって、バックライトキーをサポートします。この機能は通常スイッチごとに単一の色しか使用できないため、[RGB アンダーグロー](ja/feature_rgblight.md)および [RGB マトリックス](ja/feature_rgb_matrix.md)機能のどちらとも異なりますが、キーボードに複数の異なる単一色の LED を取り付けることは当然可能です。

-QMK は *パルス幅変調*(*Pulse Width Modulation*) すなわち PWM として知られている技術で急速にオンおよびオフを切り替えることで、これらの LED の輝度を制御できます。PWM 信号のデューティサイクルを変えることで、調光の錯覚を起こすことができます。
+QMK は *パルス幅変調* (*Pulse Width Modulation*) すなわち PWM として知られている技術で、一定の比率で素早くオンおよびオフを切り替えることで、これらの LED の輝度を制御できます。PWM 信号のデューティサイクルを変えることで、調光の錯覚を起こすことができます。

 MCU は、GPIO ピンにはそんなに電流を供給できません。MCU から直接バックライトに給電せずに、バックライトピンは LED への電力を切り替えるトランジスタあるいは MOSFET に接続されます。

-## 機能の設定
-
 ほとんどのキーボードではバックライトをサポートしている場合にデフォルトで有効になっていますが、もし機能しない場合は `rules.mk` が以下を含んでいることを確認してください:

 ```makefile
 BACKLIGHT_ENABLE = yes
 ```

-## キーコード
+## キーコード :id=keycodes
+
 有効にすると、以下のキーコードを使ってバックライトレベルを変更することができます。

-| キー | 説明 |
-|---------|------------------------------------------|
+| キー      | 説明                                 |
+| --------- | ------------------------------------ |
 | `BL_TOGG` | バックライトをオンあるいはオフにする |
-| `BL_STEP` | バックライトレベルを循環する |
-| `BL_ON` | バックライトを最大輝度に設定する |
-| `BL_OFF` | バックライトをオフにする |
-| `BL_INC` | バックライトレベルを上げる |
-| `BL_DEC` | バックライトレベルを下げる |
-| `BL_BRTG` | バックライトの明滅動作を切り替える |
+| `BL_STEP` | バックライトレベルを循環する         |
+| `BL_ON`   | バックライトを最大輝度に設定する     |
+| `BL_OFF`  | バックライトをオフにする             |
+| `BL_INC`  | バックライトレベルを上げる           |
+| `BL_DEC`  | バックライトレベルを下げる           |
+| `BL_BRTG` | バックライトの明滅動作を切り替える   |

-## バックライト関数群
+## 関数群 :id=functions

-| 関数 | 説明 |
-|----------|-----------------------------------------------------------|
-| `backlight_toggle()` | バックライトをオンあるいはオフにする |
-| `backlight_enable()` | バックライトをオンにする |
-| `backlight_disable()` | バックライトをオフにする |
-| `backlight_step()` | バックライトレベルを循環する |
-| `backlight_increase()` | バックライトレベルを上げる |
-| `backlight_decrease()` | バックライトレベルを下げる |
-| `backlight_level(x)` | バックライトのレベルを特定のレベルに設定する |
-| `get_backlight_level()` | 現在のバックライトレベルを返す |
-| `is_backlight_enabled()` | バックライトが現在オンかどうかを返す |
+次の関数を使って、カスタムコードでバックライトを変更することができます:

-### バックライトの明滅動作の関数群
+| 関数                     | 説明                                         |
+| ------------------------ | -------------------------------------------- |
+| `backlight_toggle()`     | バックライトをオンあるいはオフにする         |
+| `backlight_enable()`     | バックライトをオンにする                     |
+| `backlight_disable()`    | バックライトをオフにする                     |
+| `backlight_step()`       | バックライトレベルを循環する                 |
+| `backlight_increase()`   | バックライトレベルを上げる                   |
+| `backlight_decrease()`   | バックライトレベルを下げる                   |
+| `backlight_level(x)`     | バックライトのレベルを特定のレベルに設定する |
+| `get_backlight_level()`  | 現在のバックライトレベルを返す               |
+| `is_backlight_enabled()` | バックライトが現在オンかどうかを返す         |

-| 関数 | 説明 |
-|----------|---------------------------------------------------|
-| `breathing_toggle()` | バックライトの明滅動作をオンまたはオフにする |
-| `breathing_enable()` | バックライトの明滅動作をオンにする |
-| `breathing_disable()` | バックライトの明滅動作をオフにする |
+バックライトの明滅が有効の場合(以下を参照)、以下の関数も利用できます:

-## ドライバの設定
+| 関数                  | 説明                                         |
+|-----------------------|----------------------------------------------|
+| `breathing_toggle()`  | バックライトの明滅動作をオンまたはオフにする |
+| `breathing_enable()`  | バックライトの明滅動作をオンにする           |
+| `breathing_disable()` | バックライトの明滅動作をオフにする           |
+
+## 設定 :id=configuration

 どのドライバを使うかを選択するには、以下を使って `rules.mk` を設定します:

 ```makefile
-BACKLIGHT_DRIVER = software # 有効なドライバの値は 'pwm,software,no' です
+BACKLIGHT_DRIVER = software
 ```

-各ドライバについてのヘルプは以下を見てください。
+有効なドライバの値は `pwm`, `software`, `custom`, `no` です。各ドライバについてのヘルプは以下を見てください。

-## 共通のドライバ設定
+バックライトを設定するには、`config.h` の中で以下の `#define` をします:

-バックライトの挙動を変更するには、`config.h` の中で以下の `#define` をします:
-
-| 定義 | デフォルト | 説明 |
-|---------------------|-------------|--------------------------------------------------------------------------------------|
-| `BACKLIGHT_LEVELS` | `3` | 輝度のレベルの数 (オフを除いて最大 31) |
+| 定義                  | デフォルト | 説明                                                                                        |
+| --------------------- | ---------- | ------------------------------------------------------------------------------------------- |
+| `BACKLIGHT_PIN`       | *定義なし* | LED を制御するピン                                                                          |
+| `BACKLIGHT_LEVELS`    | `3`        | 輝度のレベルの数 (オフを除いて最大 31)                                                      |
 | `BACKLIGHT_CAPS_LOCK` | *定義なし* | バックライトを使って Caps Lock のインジケータを有効にする (専用 LED の無いキーボードのため) |
-| `BACKLIGHT_BREATHING` | *定義なし* | サポートされる場合は、バックライトの明滅動作を有効にする |
-| `BREATHING_PERIOD` | `6` | 各バックライトの "明滅" の長さ（秒） |
-| `BACKLIGHT_ON_STATE` | `0` | バックライトが "オン" の時のバックライトピンの状態 - high の場合は `1`、low の場合は `0` |
+| `BACKLIGHT_BREATHING` | *定義なし* | サポートされる場合は、バックライトの明滅動作を有効にする                                    |
+| `BREATHING_PERIOD`    | `6`        | 各バックライトの "明滅" の長さ（秒）                                                        |
+| `BACKLIGHT_ON_STATE`  | `1`        | バックライトが "オン" の時のバックライトピンの状態 - high の場合は `1`、low の場合は `0`    |

-### バックライトオン状態
+独自のキーボードを設計しているわけではない限り、通常は `BACKLIGHT_PIN` または `BACKLIGHT_ON_STATE` を変更する必要はありません。

-ほとんどのバックライトの回路は N チャンネルの MOSFET あるいは NPN トランジスタによって駆動されます。これは、トランジスタを*オン*にして LED を点灯させるには、ゲートまたはベースに接続されているバックライトピンを *high* に駆動する必要があることを意味します。
+### バックライトオン状態 :id=backlight-on-state
+
+ほとんどのバックライトの回路は N チャンネルの MOSFET あるいは NPN トランジスタによって駆動されます。これは、トランジスタを *オン* にして LED を点灯させるには、ゲートまたはベースに接続されているバックライトピンを *high* に駆動する必要があることを意味します。
 ただし、P チャンネルの MOSFET あるいは PNP トランジスタが使われる場合があります。この場合、トランジスタがオンの時、ピンは代わりに *low* で駆動されます。

-この機能は `BACKLIGHT_ON_STATE` 定義することでキーボードレベルで設定されます。
+この機能は `BACKLIGHT_ON_STATE` を定義することでキーボードレベルで設定されます。

-## AVR ドライバ
+### AVR ドライバ :id=avr-driver
+
+`pwm` ドライバはデフォルトで設定されますが、`rules.mk` 内での同等の設定は以下の通りです:

-AVR ボードでは、デフォルトのドライバは現在のところ最善のシナリオを選択するために構成を探っています。ドライバはデフォルトで設定されますが、rules.mk 内の同等の設定は以下の通りです:
 ```makefile
 BACKLIGHT_DRIVER = pwm
 ```

-### 注意事項
+#### 注意事項 :id=avr-caveats

-ハードウェア PWM は以下の表に従ってサポートされます:
+AVR ボードでは、QMK はどのドライバを使うかを以下の表に従って自動的に決定します:

 | バックライトピン | AT90USB64/128 | ATmega16/32U4 | ATmega16/32U2 | ATmega32A | ATmega328/P |
-|-------------|-------------|-------------|-------------|---------|----------|
-| `B1`        |             |             |             |         | Timer 1  |
-| `B2`        |             |             |             |         | Timer 1  |
-| `B5`        | Timer 1     | Timer 1     |             |         |          |
-| `B6`        | Timer 1     | Timer 1     |             |         |          |
-| `B7`        | Timer 1     | Timer 1     | Timer 1     |         |          |
-| `C4`        | Timer 3     |             |             |         |          |
-| `C5`        | Timer 3     |             | Timer 1     |         |          |
-| `C6`        | Timer 3     | Timer 3     | Timer 1     |         |          |
-| `D4`        |             |             |             | Timer 1 |          |
-| `D5`        |             |             |             | Timer 1 |          |
+| ---------------- | ------------- | ------------- | ------------- | --------- | ----------- |
+| `B1`             |               |               |               |           | Timer 1     |
+| `B2`             |               |               |               |           | Timer 1     |
+| `B5`             | Timer 1       | Timer 1       |               |           |             |
+| `B6`             | Timer 1       | Timer 1       |               |           |             |
+| `B7`             | Timer 1       | Timer 1       | Timer 1       |           |             |
+| `C4`             | Timer 3       |               |               |           |             |
+| `C5`             | Timer 3       |               | Timer 1       |           |             |
+| `C6`             | Timer 3       | Timer 3       | Timer 1       |           |             |
+| `D4`             |               |               |               | Timer 1   |             |
+| `D5`             |               |               |               | Timer 1   |             |

-他の全てのピンはソフトウェア PWM を使います。[オーディオ](ja/feature_audio.md)機能が無効あるいは1つのタイマだけを使っている場合は、ハードウェアタイマによってバックライト PWM を引き起こすことができます:
+他の全てのピンはタイマー支援ソフトウェア PWM を使います。

 | オーディオピン | オーディオタイマ | ソフトウェア PWM タイマ |
-|---------|-----------|------------------|
-| `C4`    | Timer 3 | Timer 1 |
-| `C5`    | Timer 3 | Timer 1 |
-| `C6`    | Timer 3 | Timer 1 |
-| `B5`    | Timer 1 | Timer 3 |
-| `B6`    | Timer 1 | Timer 3 |
-| `B7`    | Timer 1 | Timer 3 |
+| -------------- | ---------------- | ----------------------- |
+| `C4`           | Timer 3          | Timer 1                 |
+| `C5`           | Timer 3          | Timer 1                 |
+| `C6`           | Timer 3          | Timer 1                 |
+| `B5`           | Timer 1          | Timer 3                 |
+| `B6`           | Timer 1          | Timer 3                 |
+| `B7`           | Timer 1          | Timer 3                 |

-両方のタイマーがオーディオのために使われている場合、バックライト PWM はハードウェアタイマを使いませんが、代わりにマトリックススキャンの間に引き起こされます。この場合、PWM の計算は十分なタイミングの精度で呼ばれないかもしれないため、バックライトの明滅はサポートされず、バックライトもちらつくかもしれません。
+両方のタイマーがオーディオのために使われている場合、バックライト PWM はハードウェアタイマを使うことができず、代わりにマトリックススキャンの間に引き起こされます。この場合、PWM の計算は十分なタイミングの精度で呼ばれない可能性があるため、バックライトの明滅はサポートされず、バックライトもちらつくかもしれません。

-### AVR 設定
-
-バックライトの挙動を変更するには、`config.h` の中で以下の `#define` をします:
-
-| 定義 | デフォルト | 説明 |
-|---------------------|-------------|--------------------------------------------------------------------------------------------------------------|
-| `BACKLIGHT_PIN`       | `B7`      | LED を制御するピン。自身のキーボードを設計している場合を除き、これを変更する必要はないはずです |
-| `BACKLIGHT_PINS`      | *定義なし* | 実験的: 詳細は以下を見てください |
-| `BACKLIGHT_LEVELS`    | `3`       | 輝度のレベルの数 (オフを除いて最大 31) |
-| `BACKLIGHT_CAPS_LOCK` | *定義なし* | バックライトを使って Caps Lock のインジケータを有効にする (専用 LED の無いキーボードのため) |
-| `BACKLIGHT_BREATHING` | *定義なし* | サポートされる場合は、バックライトの明滅動作を有効にする |
-| `BREATHING_PERIOD`    | `6`       | 各バックライトの "明滅" の長さ（秒） |
-| `BACKLIGHT_ON_STATE`  | `1`       | バックライトが "オン" の時のバックライトピンの状態 - high の場合は `1`、low の場合は `0` |
-
-### バックライトオン状態
-
-ほとんどのバックライトの回路は N チャンネルの MOSFET あるいは NPN トランジスタによって駆動されます。これは、トランジスタを*オン*にして LED を点灯させるには、ゲートまたはベースに接続されているバックライトピンを *high* に駆動する必要があることを意味します。
-ただし、P チャンネルの MOSFET あるいは PNP トランジスタが使われる場合があります。この場合、トランジスタがオンの時、ピンは代わりに *low* で駆動されます。
-
-この機能は `BACKLIGHT_ON_STATE` 定義することでキーボードレベルで設定されます。
-
-### 複数のバックライトピン
-
-ほとんどのキーボードは、全てのバックライト LED を制御するたった1つのバックライトピンを持ちます (特にバックライトがハードウェア PWM ピンに接続されている場合)。
-ソフトウェア PWM では、複数のバックライトピンを定義することができます。これらすべてのピンは PWM デューティサイクル時に同時にオンおよびオフになります。
-この機能により、例えば Caps Lock LED (またはその他の制御可能な LED) の輝度を、バックライトの他の LED と同じレベルに設定することができます。Caps Lock の代わりに LCTRL をマップしていて、Caps Lock がオンの時に Caps Lock LED をアクティブにする代わりにバックライトの一部にする必要がある場合に便利です。
-
-複数のバックライトピンをアクティブにするには、`config.h` に次のようなものを追加する必要があります:
-
-```c
-#define BACKLIGHT_LED_COUNT 2
-#undef BACKLIGHT_PIN
-#define BACKLIGHT_PINS { F5, B2 }
-```
-
-### ハードウェア PWM 実装
+#### ハードウェア PWM 実装 :id=hardware-pwm-implementation

 バックライト用にサポートされているピンを使う場合、QMK は PWM 信号を出力するように設定されたハードウェアタイマを使います。タイマーは 0 にリセットする前に `ICRx` (デフォルトでは `0xFFFF`) までカウントします。
-希望の輝度が計算され、`OCRxx` レジスタ内に格納されます。カウンタがこの値まで達すると、バックライトピンは low になり、カウンタがリセットされると再び high になります。
+希望の輝度が計算され、`OCRxx` レジスタに格納されます。カウンタがこの値まで達すると、バックライトピンは low になり、カウンタがリセットされると再び high になります。
 このように `OCRxx` は基本的に LED のデューティサイクル、従って輝度を制御します。`0x0000` は完全にオフで、 `0xFFFF` は完全にオンです。

 明滅動作の効果はカウンタがリセットされる(秒間あたりおよそ244回)たびに呼び出される `TIMER1_OVF_vect` の割り込みハンドラを登録することで可能になります。
-このハンドラ内で、増分カウンタの値が事前に計算された輝度曲線にマップされます。明滅動作をオフにするには、割り込みを単純に禁止し、輝度を EEPROM に格納されているレベルに再設定します。
+このハンドラで、増分カウンタの値が事前に計算された輝度曲線にマップされます。明滅動作をオフにするには、割り込みを単純に禁止し、輝度を EEPROM に格納されているレベルに再設定します。

-### タイマーにアシストされた PWM 実装
+#### タイマー支援 PWM 実装 :id=timer-assisted-implementation

 `BACKLIGHT_PIN` がハードウェアバックライトピンに設定されていない場合、QMK はソフトウェア割り込みを引き起こすように設定されているハードウェアタイマを使います。タイマーは 0 にリセットする前に `ICRx` (デフォルトでは `0xFFFF`) までカウントします。
 0 に再設定すると、CPU は LED をオンにする OVF (オーバーフロー)割り込みを発火し、デューティサイクルを開始します。
-希望の輝度が計算され、`OCRxx` レジスタ内に格納されます。カウンタがこの値に達すると、CPU は比較出力一致割り込みを発火し、LED をオフにします。
+希望の輝度が計算され、`OCRxx` レジスタに格納されます。カウンタがこの値に達すると、CPU は比較出力一致割り込みを発火し、LED をオフにします。
 このように `OCRxx` は基本的に LED のデューティサイクル、従って輝度を制御します。 `0x0000` は完全にオフで、 `0xFFFF` は完全にオンです。

 明滅の効果はハードウェア PWM 実装と同じです。

-## ARM ドライバ
+### ARM ドライバ :id=arm-configuration
+
+まだ初期段階ですが、ARM バックライトサポートは最終的に AVR と同等の機能を持つことを目指しています。`pwm` ドライバはデフォルトで設定されますが、`rules.mk` 内での同等の設定は以下の通りです:

-まだ初期段階ですが、ARM バックライトサポートは最終的に AVR と同等の機能を持つことを目指しています。ドライバはデフォルトで設定されますが、rules.mk 内の同等の設定は以下の通りです:
 ```makefile
 BACKLIGHT_DRIVER = pwm
 ```

-### 注意事項
+#### ChibiOS の設定 :id=arm-configuration

-現在のところ、ハードウェア PWM のみがサポートされ、タイマーはアシストされず、自動設定は提供されません。
+以下の `#define` は ARM ベースのキーボードにのみ適用されます:

-?> STMF072 のバックライトサポートのテストは制限されています。人によって違うかもしれません。不明な場合は、rules.mk で `BACKLIGHT_ENABLE = no` を設定します。
+| 定義                    | デフォルト | 説明                    |
+| ----------------------- | ---------- | ----------------------- |
+| `BACKLIGHT_PWM_DRIVER`  | `PWMD4`    | 使用する PWM ドライバ   |
+| `BACKLIGHT_PWM_CHANNEL` | `3`        | 使用する PWM チャンネル |
+| `BACKLIGHT_PAL_MODE`    | `2`        | 使用するピン代替関数    |

-### ARM 設定
+これらの値を決定するには、特定の MCU の ST データシートを参照してください。独自のキーボードを設計しているわけではない場合、通常はこれらを変更する必要はありません。

-バックライトの挙動を変更するには、`config.h` の中で以下の `#define` をします:
+#### 注意事項 :id=arm-caveats

-| 定義 | デフォルト | 説明 |
-|------------------------|-------------|-------------------------------------------------------------------------------------------------------------|
-| `BACKLIGHT_PIN`         | `B7`    | LED を制御するピン。自身のキーボードを設計している場合を除き、これを変更する必要はないはずです |
-| `BACKLIGHT_PWM_DRIVER`  | `PWMD4` | 使用する PWM ドライバ。ピンから PWM タイマへのマッピングについては、ST データシートを見てください。自身のキーボードを設計している場合を除き、これを変更する必要はないはずです |
-| `BACKLIGHT_PWM_CHANNEL` | `3`     | 使用する PWM チャンネル。ピンから PWM チャンネルへのマッピングについては、ST データシートを見てください。自身のキーボードを設計している場合を除き、これを変更する必要はないはずです |
-| `BACKLIGHT_PAL_MODE`    | `2`     | 使用するピンの代替機能。ピンの AF マッピングについては ST データシートを見てください。自身のキーボードを設計している場合を除き、これを変更する必要はないはずです |
+現在のところ、ハードウェア PWM のみがサポートされ、タイマー支援はなく、自動設定は提供されません。

-## Software PWM Driver :id=software-pwm-driver
+?> STM32F072 のバックライトサポートのテストは制限されています。人によって違うかもしれません。不明な場合は、`rules.mk` で `BACKLIGHT_ENABLE = no` を設定します。
+
+### ソフトウェア PWM ドライバ :id=software-pwm-driver
+
+このモードでは、他のキーボードのタスクを実行中に PWM は「エミュレート」されます。追加のプラットフォーム設定なしで最大のハードウェア互換性を提供します。トレードオフは、キーボードが忙しい時にバックライトが揺れる可能性があることです。有効にするには、`rules.mk` に以下を追加します:

-他のキーボードのタスクを実行中に PWM をエミュレートすることにより、追加のプラットフォーム設定なしで最大のハードウェア互換性を提供します。トレードオフは、キーボードが忙しい時にバックライトが揺れる可能性があることです。有効にするには、rules.mk に以下を追加します:
 ```makefile
 BACKLIGHT_DRIVER = software
 ```

-### ソフトウェア PWM 設定
-
-バックライトの挙動を変更するには、`config.h` の中で以下の `#define` をします:
-
-| 定義 | デフォルト | 説明 |
-|-----------------|-------------|-------------------------------------------------------------------------------------------------------------|
-| `BACKLIGHT_PIN`  | `B7`      | LED を制御するピン。自身のキーボードを設計している場合を除き、これを変更する必要はないはずです |
-| `BACKLIGHT_PINS` | *定義なし* | 実験的: 詳細は以下を見てください |
-
-### 複数のバックライトピン
+#### 複数のバックライトピン :id=multiple-backlight-pins

 ほとんどのキーボードは、全てのバックライト LED を制御するたった1つのバックライトピンを持ちます (特にバックライトがハードウェア PWM ピンに接続されている場合)。
-ソフトウェア PWM では、複数のバックライトピンを定義することができます。これらすべてのピンは PWM デューティサイクル時に同時にオンおよびオフになります。
-この機能により、例えば Caps Lock LED (またはその他の制御可能な LED) の輝度を、バックライトの他の LED と同じレベルに設定することができます。Caps Lock の代わりに LCTRL をマップしていて、Caps Lock がオンの時に Caps Lock LED をアクティブにする代わりにバックライトの一部にする必要がある場合に便利です。
+ソフトウェア PWM では、複数のバックライトピンを定義することができます。これらのピンは PWM デューティサイクル時に同時にオンおよびオフになります。

-複数のバックライトピンをアクティブにするには、`config.h` に次のようなものを追加する必要があります:
+この機能により、例えば Caps Lock LED (またはその他の制御可能な LED) の輝度を、バックライトの他の LED と同じレベルに設定することができます。Caps Lock LED は通常バックライトとは別のピンに配線されるため、Caps Lock の代わりに Control をマップしていて、Caps Lock がオンの時に Caps Lock LED ではなくバックライトの一部をアクティブにする必要がある場合に便利です。
+
+複数のバックライトピンをアクティブにするには、`config.h` に `BACKLIGHT_PIN` の代わりに次のようなものを追加します:

 ```c
-#undef BACKLIGHT_PIN
 #define BACKLIGHT_PINS { F5, B2 }
 ```

-## カスタムドライバ
+### カスタムドライバ :id=custom-driver

-有効にするには、rules.mk に以下を追加します:
+上記ドライバのいずれもキーボードに適用されていない場合(例えば、バックライトを制御するのに別の IC を使用している場合)、QMK が提供しているこの簡単な API を使ってカスタムバックライトドライバを実装することができます。有効にするには、`rules.mk` に以下を追加します:

 ```makefile
 BACKLIGHT_DRIVER = custom
 ```

-カスタムドライバ API を実装する場合、提供されるキーボードフックは以下の通りです:
+それから次のフックのいずれかを実装します:

 ```c
 void backlight_init_ports(void) {
    // オプション - 起動時に実行されます
-    //          - 通常、ここでピンを設定します
+    //   通常、ここでピンを設定します
 }
 void backlight_set(uint8_t level) {
    // オプション - レベルの変更時に実行されます
-    //          - 通常、ここで新しい値に応答します
+    //   通常、ここで新しい値に応答します
 }

 void backlight_task(void) {
    // オプション - 定期的に実行されます
-    //          - ここで長時間実行されるアクションはパフォーマンスの問題を引き起こします
+    //   これはメインキーボードループで呼び出されることに注意してください
+    //   そのため、ここで長時間実行されるアクションはパフォーマンスの問題を引き起こします
 }
 ```
+
+## 回路図の例
+
+この一般的な例では、バックライト LED は全て N チャンネル MOSFET に向かって並列に接続されています。そのゲートピンは、リンギングを回避するため 470Ωの抵抗を介してマイクロコントローラの GPIO ピンの1つに接続されています。
+プルダウン抵抗もゲートピンとグランドの間に配置されており、MCU によって駆動されていない場合にプルダウン抵抗を定義された状態に保ちます。
+これらの抵抗値は重要ではありません。詳細については、[this Electronics StackExchange question](https://electronics.stackexchange.com/q/68748) を参照してください。
+
+![バックライトの回路例](https://i.imgur.com/BmAvoUC.png)
--- a/docs/ja/feature_debounce_type.md
+++ b/docs/ja/feature_debounce_type.md
@ -0,0 +1,47 @@
+# デバウンスアルゴリズム
+
+<!---
+  original document: 0.9.19:docs/feature_debounce_type.md
+  git diff 0.9.19 HEAD -- docs/feature_debounce_type.md | cat
+-->
+
+QMK はデバウンス API を介して複数のデバウンスアルゴリズムをサポートします。
+
+どのデバウンスメソッドが呼ばれるかのロジックは下記のとおりです。rules.mk で設定された様々な定義をチェックします。
+
+```
+DEBOUNCE_DIR:= $(QUANTUM_DIR)/debounce
+DEBOUNCE_TYPE?= sym_g
+ifneq ($(strip $(DEBOUNCE_TYPE)), custom)
+    QUANTUM_SRC += $(DEBOUNCE_DIR)/$(strip $(DEBOUNCE_TYPE)).c
+endif
+```
+
+# デバウンスの選択
+
+| DEBOUNCE_TYPE | 説明 | 他に必要なもの |
+| -------------    | ---------------------------------------------------  | ----------------------------- |
+| 未定義 | デフォルトのアルゴリズム、現在のところ sym_g を使います | 無し |
+| custom | 独自のデバウンスコードを使います | ```SRC += debounce.c``` で独自の debounce.c を追加し、必要な関数を実装します |
+| anything_else | quantum/debounce/* から他のアルゴリズムを使います | 無し |
+
+**分割キーボードについて**:
+デバウンスコードは分割キーボードと互換性があります。
+
+# 独自のデバウンスコードの使用
+* ```DEBOUNCE_TYPE = custom``` を設定します。
+* ```SRC += debounce.c``` を追加します。
+* 独自の ```debounce.c``` を追加します。例については、```quantum/debounce``` にある現在の実装をみてください。
+* 毎回のマトリクススキャンの結果はその度デバウンスによって処理されます。
+* MATRIX_ROWS ではなく num_rows を使って、分割キーボードが正しくサポートされるようにします。
+
+# インクルードされているデバウンスメソッド間での切り替え
+独自の debounce.c をインクルードすることで独自のコードを使うか、またはインクルードされている他のコードに切り替えることができます。
+含まれるデバウンスメソッドは以下の通りです:
+* eager_pr - 行ごとにデバウンスします。状態が変化すると、応答は即座に行われ、その後その行は ```DEBOUNCE``` ミリ秒の間入力されません。
+```NUM_KEYS``` の 8ビットカウンタの更新に高い計算コストがかかる、もしくは低スキャンレートのキーボード用で、各指は通常一度に1行しか叩かないようになっています。これは ErgoDox モデルに適しています; マトリックスは90度回転しているため、その「行」は実際には「列」であり、通常の使用では各指は一度に1つの「行」にしか当たりません。
+* eager_pk - キーごとにデバウンスします。状態が変化すると、応答は即座に行われ、その後そのキーは ```DEBOUNCE``` ミリ秒の間入力されません。
+* sym_g - キーボードごとにデバウンスします。状態が変化すると、グローバルタイマが設定されます。```DEBOUNCE``` ミリ秒の間何も変化がなければ、全ての入力の変更がプッシュされます。
+* sym_pk - キーごとにデバウンスします。状態が変化すると、キーごとのタイマーが設定されます。```DEBOUNCE``` ミリ秒の間そのキーに変化がなければ、キーの状態の変更がプッシュされます。
+
+
--- a/docs/ja/feature_dip_switch.md
+++ b/docs/ja/feature_dip_switch.md
@ -1,8 +1,8 @@
 # DIP スイッチ

 <!---
-  original document: 0.8.94:docs/feature_dip_switch.md
-  git diff 0.8.94 HEAD -- docs/feature_dip_switch.md | cat
+  original document: 0.9.43:docs/feature_dip_switch.md
+  git diff 0.9.43 HEAD -- docs/feature_dip_switch.md | cat
 -->

 DIP スイッチは、以下を `rules.mk` に追加することでサポートされます:
@ -12,9 +12,17 @@ DIP スイッチは、以下を `rules.mk` に追加することでサポート
 さらに、以下を `config.h` に追加します:

 ```c
+// Connects each switch in the dip switch to the GPIO pin of the MCU
 #define DIP_SWITCH_PINS { B14, A15, A10, B9 }
 ```

+あるいは
+
+```c
+// Connect each switch in the DIP switch to an unused intersections in the key matrix.
+#define DIP_SWITCH_MATRIX_GRID { {0,6}, {1,6}, {2,6} } // List of row and col pairs
+```
+
 ## コールバック

 コールバック関数を `<keyboard>.c` に記述することができます:
@ -92,4 +100,10 @@ void dip_switch_update_mask_user(uint32_t state) {

 ## ハードウェア

+### DIP スイッチの各スイッチを MCU の GPIO ピンに接続する
+
 DIP スイッチの片側は MCU のピンへ直接配線し、もう一方の側はグラウンドに配線する必要があります。機能的に同じであるため、どちら側がどちらに接続されているかは問題にはならないはずです。
+
+### DIP スイッチの各スイッチをキーマトリクスの未使用の交点に接続する
+
+キースイッチと同じように、ダイオードと DIP スイッチが ROW 線と COL 線に接続します。
--- a/docs/ja/feature_dynamic_macros.md
+++ b/docs/ja/feature_dynamic_macros.md
@ -1,8 +1,8 @@
 # 動的マクロ: ランタイムでのマクロの記録および再生

 <!---
-  original document: 0.8.123:docs/feature_dynamic_macros.md
-  git diff 0.8.123 HEAD -- docs/feature_dynamic_macros.md | cat
+  original document: 0.9.43:docs/feature_dynamic_macros.md
+  git diff 0.9.43 HEAD -- docs/feature_dynamic_macros.md | cat
 -->

 QMK はその場で作られた一時的なマクロをサポートします。これらを動的マクロと呼びます。それらはユーザがキーボードから定義し、キーボードのプラグを抜くか再起動すると失われます。
@ -23,7 +23,7 @@ QMK はその場で作られた一時的なマクロをサポートします。

 マクロの記録を開始するには、`DYN_REC_START1` または `DYN_REC_START2` のどちらかを押します。

-記録を終了するには、`DYN_REC_STOP` レイヤーボタンを押します。
+記録を終了するには、`DYN_REC_STOP` レイヤーボタンを押します。`DYN_REC_START1` または `DYN_REC_START2` をもう一度押すことでも記録を終了することができます。

 マクロを再生するには、`DYN_MACRO_PLAY1` あるいは `DYN_MACRO_PLAY2` のどちらかを押します。

--- a/docs/ja/feature_encoders.md
+++ b/docs/ja/feature_encoders.md
@ -1,8 +1,8 @@
 # エンコーダ

 <!---
-  original document: 0.8.123:docs/feature_encoders.md
-  git diff 0.8.123 HEAD -- docs/feature_encoders.md | cat
+  original document: 0.9.43:docs/feature_encoders.md
+  git diff 0.9.43 HEAD -- docs/feature_encoders.md | cat
 -->

 以下を `rules.mk` に追加することで基本的なエンコーダがサポートされます:
@ -31,7 +31,7 @@ ENCODER_ENABLE = yes
 #define ENCODER_DIRECTION_FLIP
 ```

-さらに、解像度を同じファイルで指定することができます (デフォルトかつお勧めは4):
+さらに、エンコーダが各戻り止め(デテント)間に登録するパルス数を定義する解像度は、次のように定義できます:

 ```c
 #define ENCODER_RESOLUTION 4
--- a/docs/ja/feature_hd44780.md
+++ b/docs/ja/feature_hd44780.md
@ -1,11 +1,11 @@
 # HD44780 LCD ディスプレイ

 <!---
-  original document: 0.8.123:docs/feature_hd44780.md
-  git diff 0.8.123 HEAD -- docs/feature_hd44780.md | cat
+  original document: 0.9.43:docs/feature_hd44780.md
+  git diff 0.9.43 HEAD -- docs/feature_hd44780.md | cat
 -->

-これは Peter Fleury の LCD ライブラリの統合です。このページは基本について説明します。[詳細なドキュメントについてはこのページをご覧ください](http://homepage.hispeed.ch/peterfleury/doxygen/avr-gcc-libraries/group__pfleury__lcd.html) (訳注）原文のリンク先のページは、サービスの終了に伴って削除されています。移行先は (http://www.peterfleury.epizy.com/doxygen/avr-gcc-libraries/group__pfleury__lcd.html) と思われます。
+これは Peter Fleury の LCD ライブラリの統合です。このページは基本について説明します。[詳細なドキュメントについてはこのページをご覧ください](http://www.peterfleury.epizy.com/doxygen/avr-gcc-libraries/group__pfleury__lcd.html)

 HD44780 ディスプレイのサポートを有効にするには、キーボードの `rules.mk` の `HD44780_ENABLE` フラグを yes に設定します。

@ -59,4 +59,4 @@ LCD_DISP_ON_CURSOR_BLINK : ディスプレイオン、点滅カーソル

 ディスプレイに何かを表示するには、最初に `lcd_gotoxy(column, line)` を呼びます。最初の行の先頭に移動するには、`lcd_gotoxy(0, 0)` を呼び出し、その後 `lcd_puts("example string")` を使って文字列を出力します。

-ディスプレイを制御することができる、より多くのメソッドがあります。[詳細なドキュメントについてはリンクされたページをご覧ください](http://homepage.hispeed.ch/peterfleury/doxygen/avr-gcc-libraries/group__pfleury__lcd.html) (訳注）原文のリンク先のページは、サービスの終了に伴って削除されています。移行先は (http://www.peterfleury.epizy.com/doxygen/avr-gcc-libraries/group__pfleury__lcd.html) と思われます。
+ディスプレイを制御することができる、より多くのメソッドがあります。[詳細なドキュメントについてはリンクされたページをご覧ください](http://www.peterfleury.epizy.com/doxygen/avr-gcc-libraries/group__pfleury__lcd.html)
--- a/docs/ja/feature_layers.md
+++ b/docs/ja/feature_layers.md
@ -1,8 +1,8 @@
 # レイヤー :id=layers

 <!---
-  original document: 0.9.20:docs/feature_layers.md
-  git diff 0.9.20 HEAD -- docs/feature_layers.md | cat
+  original document: 0.9.43:docs/feature_layers.md
+  git diff 0.9.43 HEAD -- docs/feature_layers.md | cat
 -->

 QMK ファームウェアの最も強力で良く使われている機能の一つは、レイヤーを使う機能です。ほとんどの人にとって、これはラップトップやタブレットキーボードにあるのと同じように、様々なキーを可能にするファンクションキーに相当します。
@ -58,42 +58,42 @@ QMK を使い始めたばかりの場合は、全てを単純にしたいでし

 レイヤーの使用あるいは操作に関係する多くの関数(と変数)があります。

-| 関数 | 説明 |
-|----------------------------------------------|---------------------------------------------------------------------------------------------------------|
-| `layer_state_set(layer_mask)` | 直接レイヤーの状態を設定する (推奨。何をしているのか分かっていない場合は使わないでください)。 |
-| `layer_clear()` | 全てのレイヤーを消去する (全てをオフにします)。 |
-| `layer_move(layer)` | 指定されたレイヤーをオンにし、それ以外をオフにする。 |
-| `layer_on(layer)` | 指定されたレイヤーをオンにし、それ以外を既存の状態のままにする。 |
-| `layer_off(layer)` | 指定されたレイヤーをオフにし、それ以外を既存の状態のままにする。 |
-| `layer_invert(layer)` | 指定されたレイヤーの状態を反転/トグルする。 |
-| `layer_or(layer_mask)` | 指定されたレイヤーと既存のレイヤー状態の間で一致するビットに基づいてレイヤーをオンにする。 |
-| `layer_and(layer_mask)` | 指定されたレイヤーと既存のレイヤー状態の間で有効なビットに基づいてレイヤーをオンにする。 |
-| `layer_xor(layer_mask)` | 指定されたレイヤーと既存のレイヤー状態の間で一致しないビットに基づいてレイヤーをオンにする。 |
-| `layer_debug(layer_mask)` | デバッガのコンソールに現在のビットマスクと最も高いレイヤーを出力する。 |
-| `default_layer_set(layer_mask)` | 直接デフォルトレイヤーの状態を設定する (推奨。何をしているのか分かっていない場合は使わないでください)。 |
-| `default_layer_or(layer_mask)` | 指定されたレイヤーと既存のデフォルトレイヤー状態の間で一致するビットに基づいてレイヤーをオンにする。 |
-| `default_layer_and(layer_mask)` | 指定されたレイヤーと既存のデフォルトレイヤー状態の間で一致する有効なビットに基づいてレイヤーをオンにする。 |
-| `default_layer_xor(layer_mask)` | 指定されたレイヤーと既存のデフォルトレイヤー状態の間で一致しないビットに基づいてレイヤーをオンにする。 |
-| `default_layer_debug(layer_mask)` | デバッガのコンソールに現在のビットマスクと最も高いアクティブなレイヤーを出力する。 |
-| [`set_single_persistent_default_layer(layer)`](ja/ref_functions.md#setting-the-persistent-default-layer) | デフォルトレイヤーを設定し、それを永続化メモリ (EEPROM) に書き込む。 |
-| [`update_tri_layer(x, y, z)`](ja/ref_functions.md#update_tri_layerx-y-z) | レイヤー `x` と `y` の両方がオンであるかを調べ、それに基づいて `z` を設定する(両方がオンの場合オン、そうでなければオフ)。 |
-| [`update_tri_layer_state(state, x, y, z)`](ja/ref_functions.md#update_tri_layer_statestate-x-y-z) | `update_tri_layer(x, y, z)` と同じことをするが、`layer_state_set_*` 関数から呼ばれる。 |
+| 関数                                         | 説明                                                                                                       |
+| -------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
+| `layer_state_set(layer_mask)`                | 直接レイヤーの状態を設定する (推奨。何をしているのか分かっていない場合は使わないでください)。              |
+| `layer_clear()`                              | 全てのレイヤーを消去する (全てをオフにします)。                                                            |
+| `layer_move(layer)`                          | 指定されたレイヤーをオンにし、それ以外をオフにする。                                                       |
+| `layer_on(layer)`                            | 指定されたレイヤーをオンにし、それ以外を既存の状態のままにする。                                           |
+| `layer_off(layer)`                           | 指定されたレイヤーをオフにし、それ以外を既存の状態のままにする。                                           |
+| `layer_invert(layer)`                        | 指定されたレイヤーの状態を反転/トグルする。                                                                |
+| `layer_or(layer_mask)`                       | 指定されたレイヤーと既存のレイヤー状態の間で一致するビットに基づいてレイヤーをオンにする。                 |
+| `layer_and(layer_mask)`                      | 指定されたレイヤーと既存のレイヤー状態の間で有効なビットに基づいてレイヤーをオンにする。                   |
+| `layer_xor(layer_mask)`                      | 指定されたレイヤーと既存のレイヤー状態の間で一致しないビットに基づいてレイヤーをオンにする。               |
+| `layer_debug(layer_mask)`                    | デバッガのコンソールに現在のビットマスクと最も高いレイヤーを出力する。                                     |
+| `default_layer_set(layer_mask)`              | 直接デフォルトレイヤーの状態を設定する (推奨。何をしているのか分かっていない場合は使わないでください)。    |
+| `default_layer_or(layer_mask)`               | 指定されたレイヤーと既存のデフォルトレイヤー状態の間で一致するビットに基づいてレイヤーをオンにする。       |
+| `default_layer_and(layer_mask)`              | 指定されたレイヤーと既存のデフォルトレイヤー状態の間で一致する有効なビットに基づいてレイヤーをオンにする。 |
+| `default_layer_xor(layer_mask)`              | 指定されたレイヤーと既存のデフォルトレイヤー状態の間で一致しないビットに基づいてレイヤーをオンにする。     |
+| `default_layer_debug(layer_mask)`            | デバッガのコンソールに現在のビットマスクと最も高いアクティブなレイヤーを出力する。                         |
+| [`set_single_persistent_default_layer(layer)`](ja/ref_functions.md#setting-the-persistent-default-layer) | デフォルトレイヤーを設定し、それを永続化メモリ (EEPROM) に書き込む。                                                      |
+| [`update_tri_layer(x, y, z)`](ja/ref_functions.md#update_tri_layerx-y-z)                                 | レイヤー `x` と `y` の両方がオンであるかを調べ、それに基づいて `z` を設定する(両方がオンの場合オン、そうでなければオフ)。 |
+| [`update_tri_layer_state(state, x, y, z)`](ja/ref_functions.md#update_tri_layer_statestate-x-y-z)        | `update_tri_layer(x, y, z)` と同じことをするが、`layer_state_set_*` 関数から呼ばれる。                                    |


 呼び出すことができる関数に加えて、レイヤーが変更されるたびに呼び出されるコールバック関数が幾つかあります。これはレイヤー状態を関数に渡し、読み取りや変更することができます。

-| コールバック | 説明 |
-|-----------------------------------------------------|----------------------------------------------------------------------------------------|
-| `layer_state_set_kb(layer_state_t state)` | キーボードレベルのレイヤー関数のためのコールバック。 |
-| `layer_state_set_user(layer_state_t state)` | ユーザレベルのレイヤー関数のためのコールバック。 |
-| `default_layer_state_set_kb(layer_state_t state)` | キーボードレベルのデフォルトレイヤー関数のためのコールバック。キーボードの初期化時に呼ばれます。 |
-| `default_layer_state_set_user(layer_state_t state)` | ユーザレベルのデフォルトレイヤー関数のためのコールバック。キーボードの初期化時に呼ばれます。 |
+| コールバック                                        | 説明                                                                                             |
+| --------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
+| `layer_state_set_kb(layer_state_t state)`           | キーボードレベルのレイヤー関数のためのコールバック。                                             |
+| `layer_state_set_user(layer_state_t state)`         | ユーザレベルのレイヤー関数のためのコールバック。                                                 |
+| `default_layer_state_set_kb(layer_state_t state)`   | キーボードレベルのデフォルトレイヤー関数のためのコールバック。キーボードの初期化時に呼ばれます。 |
+| `default_layer_state_set_user(layer_state_t state)` | ユーザレベルのデフォルトレイヤー関数のためのコールバック。キーボードの初期化時に呼ばれます。     |

 ?> これらのコールバックを使うための追加の情報については、[レイヤー変換コード](ja/custom_quantum_functions.md#layer-change-code)のドキュメントを調べてください。

-| チェック関数 | 説明 |
-|-------------------------------------------|------------------------------------------------------------------------------|
-| `layer_state_cmp(cmp_layer_state, layer)` | これは `cmp_layer_state` を調べて、指定された `layer` が有効かどうかを確認します。これは、レイヤーコールバックで使うためのものです。 |
-| `layer_state_is(layer)` | これはレイヤーの状態を調べて、指定された `layer` が有効かどうかを確認します。(グローバルレイヤー状態については、`layer_state_cmp` を呼びます)。 |
+次の関数やマクロを使って、特定のレイヤーの状態を確認することもできます。

-!> `IS_LAYER_ON(layer)` もありますが、`layer_state_cmp` 関数には、レイヤー0で正しい値を返すようにするために追加の処理があります。さもないと、レイヤー0がオンになっているかどうかを確認する時に誤った値が返されることがあります。
+| 関数                            | 説明                                                                                                          | 別名                                                                  |
+| ------------------------------- | ------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- |
+| `layer_state_is(layer)`         | 指定された `layer` がグローバルに有効かどうかを確認する。                                                     | `IS_LAYER_ON(layer)`, `IS_LAYER_OFF(layer)`                           |
+| `layer_state_cmp(state, layer)` | `state` を確認して指定された `layer` が有効かどうかを確認する。レイヤーのコールバックで使うことを目的とする。 | `IS_LAYER_ON_STATE(state, layer)`, `IS_LAYER_OFF_STATE(state, layer)` |
--- a/docs/ja/feature_macros.md
+++ b/docs/ja/feature_macros.md
@ -1,8 +1,8 @@
 # マクロ

 <!---
-  original document: 0.8.169:docs/feature_macros.md
-  git diff 0.8.169 HEAD -- docs/feature_macros.md | cat
+  original document: 0.9.43:docs/feature_macros.md
+  git diff 0.9.43 HEAD -- docs/feature_macros.md | cat
 -->

 マクロにより、1つのキーを押すだけで複数のキーストロークを送信することができます。QMK にはマクロを定義し使う方法が幾つかあります。これらはなんでもすることができます: よく使うフレーズの入力、コピーペースト、反復的なゲームの動き、あるいはコードを書くことさえ手助けします。
@ -11,34 +11,34 @@

 ## 新しい方法: `SEND_STRING()` と `process_record_user`

-単語またはフレーズを入力するキーが欲しい時があります。最も一般的な状況のために `SEND_STRING()` を提供しています。これは文字列(つまり、文字のシーケンス)を入力します。簡単にキーコードに変換することができる全ての ASCII 文字がサポートされています (例えば、`\n\t`)。
+単語またはフレーズを入力するキーが欲しい時があります。最も一般的な状況のために `SEND_STRING()` を提供しています。これは文字列(つまり、文字のシーケンス)を入力します。簡単にキーコードに変換することができる全ての ASCII 文字がサポートされています (例えば、`qmk 123\n\t`)。

 以下は2キーのキーボードのための `keymap.c` の例です:

 ```c
 enum custom_keycodes {
-  QMKBEST = SAFE_RANGE,
+    QMKBEST = SAFE_RANGE,
 };

 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-  switch (keycode) {
+    switch (keycode) {
    case QMKBEST:
-      if (record->event.pressed) {
-        // キーコード QMKBEST が押された時
-        SEND_STRING("QMK is the best thing ever!");
-      } else {
-        // キーコード QMKBEST が放された時
-      }
-      break;
-
-  }
-  return true;
+        if (record->event.pressed) {
+            // キーコード QMKBEST が押された時
+            SEND_STRING("QMK is the best thing ever!");
+        } else {
+            // キーコード QMKBEST が放された時
+        }
+        break;
+    }
+    return true;
 };

 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-  [0] = {
-    {QMKBEST, KC_ESC}
-  }
+    [0] = {
+        {QMKBEST, KC_ESC},
+        // ...
+    },
 };
 ```

@ -54,42 +54,45 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {

 ```c
 enum custom_keycodes {
-  QMKBEST = SAFE_RANGE,
-  QMKURL,
-  MY_OTHER_MACRO
+    QMKBEST = SAFE_RANGE,
+    QMKURL,
+    MY_OTHER_MACRO,
 };

 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-  switch (keycode) {
+    switch (keycode) {
    case QMKBEST:
-      if (record->event.pressed) {
-        // キーコード QMKBEST が押された時
-        SEND_STRING("QMK is the best thing ever!");
-      } else {
-        // キーコード QMKBEST が放された時
-      }
-      break;
+        if (record->event.pressed) {
+            // キーコード QMKBEST が押された時
+            SEND_STRING("QMK is the best thing ever!");
+        } else {
+            // キーコード QMKBEST が放された時
+        }
+        break;
+
    case QMKURL:
-      if (record->event.pressed) {
-        // キーコード QMKURL が押された場合
-        SEND_STRING("https://qmk.fm/\n");
-      } else {
-        // キーコード QMKURL が放された場合
-      }
-      break;
+        if (record->event.pressed) {
+            // キーコード QMKURL が押された場合
+            SEND_STRING("https://qmk.fm/\n");
+        } else {
+            // キーコード QMKURL が放された場合
+        }
+        break;
+
    case MY_OTHER_MACRO:
-      if (record->event.pressed) {
-                SEND_STRING(SS_LCTL("ac")); // 全てを選択しコピーします
-      }
-      break;
-  }
-  return true;
+        if (record->event.pressed) {
+           SEND_STRING(SS_LCTL("ac")); // 全てを選択しコピーします
+        }
+        break;
+    }
+    return true;
 };

 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-  [0] = {
-    {MY_CUSTOM_MACRO, MY_OTHER_MACRO}
-  }
+    [0] = {
+        {MY_CUSTOM_MACRO, MY_OTHER_MACRO},
+        // ...
+    },
 };
 ```

--- a/docs/ja/feature_mouse_keys.md
+++ b/docs/ja/feature_mouse_keys.md
@ -1,8 +1,8 @@
 # マウスキー

 <!---
-  original document: 0.8.141:docs/feature_mouse_keys.md
-  git diff 0.8.141 HEAD -- docs/feature_mouse_keys.md | cat
+  original document: 0.9.44:docs/feature_mouse_keys.md
+  git diff 0.9.44 HEAD -- docs/feature_mouse_keys.md | cat
 -->

 マウスキーは、キーボードを使ってマウスをエミュレートできる機能です。様々な速度でポインタを移動し、5つのボタンを押し、8方向にスクロールすることができます。
@ -44,10 +44,11 @@ MOUSEKEY_ENABLE = yes

 ## マウスキーの設定

-マウスキーはカーソルを移動するための2つの異なるモードをサポートします:
+マウスキーはカーソルを移動するための3つの異なるモードをサポートします:

 * **加速 (デフォルト):** 移動キーを押したままにすると、カーソルが最大速度に達するまでカーソルを加速します。
 * **定速:** 移動キーを押したままにすると、カーソルを一定の速度で移動します。
+* **混合:** 移動キーを押したままにすると、カーソルが最大速度に達するまでカーソルを加速し、加速キーと移動キーを同時に押すとカーソルは一定の速度で移動します。

 同じ原則がスクロールにも適用されます。

@ -125,3 +126,19 @@ MOUSEKEY_ENABLE = yes
 | `MK_W_INTERVAL_1` | 120 | スクロールステップ間の時間 (`KC_ACL1`) |
 | `MK_W_OFFSET_2` | 1 | スクロールアクションごとのスクロールステップ (`KC_ACL2`) |
 | `MK_W_INTERVAL_2` | 20 | スクロールステップ間の時間 (`KC_ACL2`) |
+
+### 混合モード
+
+このモードは **加速** モードのように機能しますが、`KC_ACL0`、`KC_ACL1`、`KC_ACL2` を押したままにすることで
+一時的(押している間)にカーソルとスクロール速度を定速に設定できます。
+加速キーが押されていない場合、このモードは **加速** モードと同じで、関連する全ての設定を使って変更できます。
+
+* **KC_ACL0:** この加速はカーソルをできるだけ遅い速度に設定します。これはカーソルを非常に小さく詳細に移動する場合に便利です。
+* **KC_ACL1:** この加速はカーソルを最大(ユーザ定義)速度の半分に設定します。
+* **KC_ACL2:** この加速はカーソルを最大(コンピュータ定義)速度に設定します。これは、正確性を多少犠牲にしてカーソルを大きく移動する場合に便利です。
+
+混合モードを使うには、キーマップの `config.h` ファイルに少なくとも `MK_COMBINED` を定義しなければなりません:
+
+```c
+#define MK_COMBINED
+```
--- a/docs/ja/feature_pointing_device.md
+++ b/docs/ja/feature_pointing_device.md
@ -1,8 +1,8 @@
 # ポインティングデバイス :id=pointing-device

 <!---
-  original document: 0.8.182:docs/feature_pointing_device.md
-  git diff 0.8.182 HEAD -- docs/feature_pointing_device.md | cat
+  original document: 0.9.43:docs/feature_pointing_device.md
+  git diff 0.9.43 HEAD -- docs/feature_pointing_device.md | cat
 -->

 ポインティングデバイスは汎用的な機能の総称です: システムポインタを移動します。マウスキーのような他のオプションも確かにありますが、これは簡単に変更可能で軽量であることを目指しています。機能を制御するためにカスタムキーを実装したり、他の周辺機器から情報を収集してここに直接挿入したりできます - QMK に処理を任せてください。
@ -26,7 +26,11 @@ report_mouse_t (ここでは "mouseReport") が以下のプロパティを持つ
 * `mouseReport.h` - これは、水平スクロール(+ 右へ、- 左へ)を表す -127 から 127 (128ではなく、USB HID 仕様で定義されています)の符号付き整数です。
 * `mouseReport.buttons` - これは uint8_t で、上位の5ビットを使っています。これらのビットはマウスボタンの状態を表します - ビット 3 はマウスボタン 5、ビット 7 はマウスボタン 1 です。

-マウスレポートが送信されると、x、y、v、h のいずれの値も 0 に設定されます (これは "pointing_device_send()" で行われます。この挙動を回避するためにオーバーライドすることができます)。このように、ボタンの状態は持続しますが、動きは1度だけ起こります。さらにカスタマイズするために、`pointing_device_init` と `pointing_device_task` のどちらもオーバーライドすることができます。
+マウスレポートに必要な変更を行ったら、それを送信する必要があります:
+
+* `pointing_device_send()` - マウスレポートをホストに送信し、レポートをゼロにします。
+
+マウスレポートが送信されると、x、y、v、h のいずれの値も 0 に設定されます (これは `pointing_device_send()` で行われます。この挙動を回避するためにオーバーライドすることができます)。このように、ボタンの状態は持続しますが、動きは1度だけ起こります。さらにカスタマイズするために、`pointing_device_init` と `pointing_device_task` のどちらもオーバーライドすることができます。

 以下の例では、カスタムキーを使ってマウスをクリックし垂直および水平方向に127単位スクロールし、リリースされた時にそれを全て元に戻します - なぜならこれは完全に便利な機能だからです。いいですか、以下はひとつの例です:

@ -43,6 +47,7 @@ case MS_SPECIAL:
        currentReport.buttons &= ~MOUSE_BTN1;
    }
    pointing_device_set_report(currentReport);
+    pointing_device_send();
    break;
 ```

--- a/docs/ja/feature_ps2_mouse.md
+++ b/docs/ja/feature_ps2_mouse.md
@ -1,8 +1,8 @@
 # PS/2 マウスサポート :id=ps2-mouse-support

 <!---
-  original document: 0.8.147:docs/feature_ps2_mouse.md
-  git diff 0.8.147 HEAD -- docs/feature_ps2_mouse.md | cat
+  original document: 0.9.44:docs/feature_ps2_mouse.md
+  git diff 0.9.44 HEAD -- docs/feature_ps2_mouse.md | cat
 -->

 PS/2 マウス (例えばタッチパッドあるいはトラックポイント)を複合デバイスとしてキーボードに接続することができます。
@ -291,3 +291,13 @@ X 軸と Y 軸を反転するには、以下を config.h に配置します:
 #define PS2_MOUSE_DEBUG_HID
 #define PS2_MOUSE_DEBUG_RAW
 ```
+
+### 動作フック :id=movement-hook
+
+ホストに送信される前にキーマップでマウスの動作を処理します。使用例として、
+ノイズのフィルタリング、加速の追加、レイヤーの自動アクティブ化が含まれます。
+使用するには、キーマップで次の関数を定義します:
+
+```c
+void ps2_mouse_moved_user(report_mouse_t *mouse_report);
+```
--- a/docs/ja/feature_split_keyboard.md
+++ b/docs/ja/feature_split_keyboard.md
@ -1,8 +1,8 @@
 # 分割キーボード

 <!---
-  original document:0.9.5:docs/feature_split_keyboard.md
-  git diff 0.9.5 HEAD -- docs/feature_split_keyboard.md | cat
+  original document:0.9.43:docs/feature_split_keyboard.md
+  git diff 0.9.43 HEAD -- docs/feature_split_keyboard.md | cat
 -->

 QMK ファームウェアリポジトリの多くのキーボードは、"分割"キーボードです。それらは2つのコントローラを使います — 1つは USB に接続し、もう1つは TRRS または同様のケーブルを介してシリアルまたは I<sup>2</sup>C 接続で接続します。
@ -95,6 +95,24 @@ SPLIT_TRANSPORT = custom

 これは指定されたピンを読み込みます。high の場合、コントローラはそれを左側だと仮定し、low の場合、それは右側であると仮定します。

+#### マトリックスピンによる左右の設定
+
+左右を決定するためにコントローラのキーマトリックスピンを読むようにファームウェアを設定することができます。これを行うには、以下を `config.h` ファイルに追加します:
+
+```c
+#define SPLIT_HAND_MATRIX_GRID D0, F1
+```
+
+最初のピンは出力ピンで、2つ目は入力ピンです。
+
+キーマトリックスに未使用の交点があるキーボードがあります。この設定は、左右の決定にこれらの未使用の交点の1つを使用します。
+
+通常、ダイオードが交点に接続されている場合、左側と判断されます。次の定義を追加すると、右側と判断されます。
+
+```c
+#define SPLIT_HAND_MATRIX_GRID_LOW_IS_RIGHT
+```
+
 #### EEPROM による左右の設定

 このメソッドは永続ストレージ(`EEPROM`)のフラグを設定することで、キーボードの左右を設定します。これはコントローラが最初に起動する時にチェックされ、キーボードのどちら側であるかとキーボードのレイアウトの向きを決定します。
--- a/docs/ja/feature_stenography.md
+++ b/docs/ja/feature_stenography.md
@ -0,0 +1,136 @@
+# QMK での速記 :id=stenography-in-qmk
+
+<!---
+  original document: 0.9.19:docs/feature_stenography.md
+  git diff 0.9.19 HEAD -- docs/feature_stenography.md | cat
+-->
+
+[速記](https://en.wikipedia.org/wiki/Stenotype)は裁判所のレポート、字幕および耳が不自由な人のためのリアルタイムの文字起こしで最もよく使われる記述方法です。速記では単語はスペル、音声およびショートカット(短い)ストロークが混在する音節ごとに音節化されます。プロの速記者は、標準的なタイピングで通常見られる負担を掛けずに、はるかに少ないエラー(99.9%より高い精度)で、200-300 WPM に到達できます。
+
+[Open Steno Project](http://www.openstenoproject.org/)は、速記ストロークを単語とコマンドにリアルタイムに変換する Plover と呼ばれるオープンソースプログラムを構築しました。確立された辞書とサポートがあります。
+
+## QWERTY キーボードを使った Plover :id=plover-with-qwerty-keyboard
+
+Plover は全ての標準的な QWERTY キーボードで動作しますが、キーボードが NKRO (n-キーロールオーバー)をサポートする場合は Plover は一度に押された全てのキーが分かるためより効率的です。Plover 用のキーマップの例は `planck/keymaps/default` で見つかります。`PLOVER` レイヤーに切り替えると、数字バーをサポートするためにキーボードの位置が調整されます。
+
+QMK で Plover を使うには、NKRO を有効にし、標準レイアウト以外のレイアウトの場合はオプションでレイアウトを調整します。複数のキーを押しやすくするために、なんらかの速記フレンドリなキーキャップを購入することもできます。
+
+## 速記プロトコルを使った Plover :id=plover-with-steno-protocol
+
+Plover は幾つかの速記マシンの言語も理解します。QMK はこれらの言語の内2つの言語、TX Bolt と GeminiPR を話すことができます。レイアウトの例は `planck/keymaps/steno` で見つけることができます。
+
+QMKが steno プロトコルを使って Plover と話す場合は、Plover は入力としてキーボードを使いません。標準のキーボードと速記キーボードを行き来したり、あるいは Plover をアクティブ/非アクティブにする必要なく Plover と標準のレイヤーを行き来することができることを意味します。
+
+このモードでは、Plover はシリアルポートを介して速記マシンと通信すると想定しているため、QMK はオペレーティングシステムに対してキーボードに加えて仮想シリアルポートとして存在しています。デフォルトでは、QMK は TX Bolt プロトコルを話しますが、GeminiPR に切り替えることができます; 最後に使われたプロトコルが不揮発性メモリに格納されるため QMK は再起動時に同じプロトコルを使います。
+
+> 注意: ハードウェアの制限により、仮想シリアルポートとマウスエミュレーションの両方を同時に実行することができないかもしれません。
+
+### TX Bolt :id=tx-bolt
+
+TX Bolt は可変サイズ(1-5バイト)のパケットで非常に単純なプロトコルを介して24個のキーのステータスを通信します。
+
+### GeminiPR :id=geminipr
+
+GeminiPR は42個のキーを6バイトのパケットにエンコードします。TX Bolt は標準的な速記に必要な全てを含んでいますが、GeminiPR は英語以外の速記法のサポートを含む、より多くのオプションにも開け放たれています。
+
+## 速記のための QMK の設定 :id=configuring-qmk-for-steno
+
+最初にキーマップの Makefile で速記を有効にします。競合を避けるために、マウスキー、追加キーあるいはその他の USB エンドポイントを無効にする必要もあります。幾つかのプロセッサの内蔵の USB スタックは一定数の USB エンドポイントと仮想シリアルポートのみをサポートし、速記はそれらのうちの3つを使います。
+
+```makefile
+STENO_ENABLE = yes
+MOUSEKEY_ENABLE = no
+```
+
+キーマップで Plover 用の新しいレイヤーを作成します。`keymap_steno.h` をインクルードする必要があります。例については `planck/keymaps/steno/keymap.c` を見てください。レイヤーに切り替えるためのキーとレイヤーから抜けるためのキーを作成することを忘れないでください。その場でモードを切り替えたい場合は、キーコード `QK_STENO_BOLT` および `QK_STENO_GEMINI` を使うことができます。プロトコルのうちの1つのみを使う場合は、初期化関数の中でそれをセットアップすることができます:
+
+```c
+void matrix_init_user() {
+  steno_set_mode(STENO_MODE_GEMINI); // あるいは STENO_MODE_BOLT
+}
+```
+
+キーボードを書き込んだら、Plover を起動します。'Configure...' ボタンをクリックします。'Machine' タブの中で目的のプロトコルに対応する速記マシンを選択します。このタブの 'Configure...' ボタンをクリックし、シリアルポートを入力するか 'Scan' をクリックします。ボーレートは 9600 で問題ありません (ただし、115200まで問題無く設定することができるはずです)。それ以外はデフォルトの設定(データビット長: 8、ストップビット長: 1、パリティチェック: なし、フロー制御なし)を使います。
+
+ディスプレイタブで 'Open stroke display' をクリックします。Plover を無効にすると、キーボードのキーを押すとストローク表示ウィンドウにそれらが表示されるはずです。これを使ってキーマップが正しくセットアップされたことを確認してください。これで速記をする準備ができました！
+
+## 速記の学習 :id=learning-stenography
+
+* [Learn Plover!](https://sites.google.com/site/learnplover/)
+* [QWERTY Steno](http://qwertysteno.com/Home/)
+* [Steno Jig](https://joshuagrams.github.io/steno-jig/)
+* Plover [Learning Stenography](https://github.com/openstenoproject/plover/wiki/Learning-Stenography) wiki のより多くのリソース
+
+## コードとのインターフェイス :id=interfacing-with-the-code
+
+速記コードには3つの捕捉可能なフックがあります。これらの関数を定義した場合、処理の特定のポイントでそれらが呼び出されます; それらが true を返す場合処理が継続され、そうでなければあなたが物事を処理すると想定します。
+
+```c
+bool send_steno_chord_user(steno_mode_t mode, uint8_t chord[6]);
+```
+
+この関数はコードが送信されようとしている時に呼ばれます。モードは `STENO_MODE_BOLT` あるいは `STENO_MODE_GEMINI` のいずれかです。これはいずれかのプロトコルを介して送信される実際のコードを表します。提供されるコードを修正して送信されるものを変更することができます。通常の送信プロセスにしたい場合は true を返すのを忘れないでください。
+
+```c
+bool process_steno_user(uint16_t keycode, keyrecord_t *record) { return true; }
+```
+
+この関数はキーが押されるとキーが処理される前に呼び出されます。キーコードは `QK_STENO_BOLT`、`QK_STENO_GEMINI` あるいは `STN_*` キー値のいずれかでなければなりません。
+
+```c
+bool postprocess_steno_user(uint16_t keycode, keyrecord_t *record, steno_mode_t mode, uint8_t chord[6], int8_t pressed);
+```
+
+この関数はキーが処理された後、ただしコードを送信するかどうかを決める前に呼び出されます。`IS_PRESSED(record->event)` が false で、`pressed` が 0 または 1 の場合は、コードはまもなく送信されますが、まだ送信されてはいません。ここが速記コードあるいはキーのライブ表示などのフックを配置する場所です。
+
+
+## キーコードリファレンス :id=keycode-reference
+
+`keymap_steno.h` で定義されています。
+
+> 注意: TX Bolt はキーの完全なセットをサポートしません。QMK での TX Bolt の実装は、GeminiPR キーを最も近い TX Bolt キーにマップします。そのため1つのキーマップが両方で動作します。
+
+| GeminiPR | TX Bolt | Steno Key |
+|--------|-------|-----------|
+| `STN_N1` | `STN_NUM` | Number bar #1 |
+| `STN_N2` | `STN_NUM` | Number bar #2 |
+| `STN_N3` | `STN_NUM` | Number bar #3 |
+| `STN_N4` | `STN_NUM` | Number bar #4 |
+| `STN_N5` | `STN_NUM` | Number bar #5 |
+| `STN_N6` | `STN_NUM` | Number bar #6 |
+| `STN_N7` | `STN_NUM` | Number bar #7 |
+| `STN_N8` | `STN_NUM` | Number bar #8 |
+| `STN_N9` | `STN_NUM` | Number bar #9 |
+| `STN_NA` | `STN_NUM` | Number bar #A |
+| `STN_NB` | `STN_NUM` | Number bar #B |
+| `STN_NC` | `STN_NUM` | Number bar #C |
+| `STN_S1` | `STN_SL` | `S-` upper |
+| `STN_S2` | `STN_SL` | `S-` lower |
+| `STN_TL` | `STN_TL` | `T-` |
+| `STN_KL` | `STN_KL` | `K-` |
+| `STN_PL` | `STN_PL` | `P-` |
+| `STN_WL` | `STN_WL` | `W-` |
+| `STN_HL` | `STN_HL` | `H-` |
+| `STN_RL` | `STN_RL` | `R-` |
+| `STN_A` | `STN_A` | `A` vowel |
+| `STN_O` | `STN_O` | `O` vowel |
+| `STN_ST1` | `STN_STR` | `*` upper-left |
+| `STN_ST2` | `STN_STR` | `*` lower-left |
+| `STN_ST3` | `STN_STR` | `*` upper-right |
+| `STN_ST4` | `STN_STR` | `*` lower-right |
+| `STN_E` | `STN_E` | `E` vowel |
+| `STN_U` | `STN_U` | `U` vowel |
+| `STN_FR` | `STN_FR` | `-F` |
+| `STN_PR` | `STN_PR` | `-P` |
+| `STN_RR` | `STN_RR` | `-R` |
+| `STN_BR` | `STN_BR` | `-B` |
+| `STN_LR` | `STN_LR` | `-L` |
+| `STN_GR` | `STN_GR` | `-G` |
+| `STN_TR` | `STN_TR` | `-T` |
+| `STN_SR` | `STN_SR` | `-S` |
+| `STN_DR` | `STN_DR` | `-D` |
+| `STN_ZR` | `STN_ZR` | `-Z` |
+| `STN_FN` | (GeminiPR のみ) |
+| `STN_RES1` | (GeminiPR のみ) |
+| `STN_RES2` | (GeminiPR のみ) |
+| `STN_PWR` | (GeminiPR のみ) |
--- a/docs/ja/feature_tap_dance.md
+++ b/docs/ja/feature_tap_dance.md
@ -1,39 +1,28 @@
 # タップダンス: 1つのキーが3つ、5つまたは100の異なる動作をします

 <!---
-  original document: 0.9.0:docs/feature_tap_dance.md
-  git diff 0.9.0 HEAD -- docs/feature_tap_dance.md | cat
+  original document: 0.9.44:docs/feature_tap_dance.md
+  git diff 0.9.44 HEAD -- docs/feature_tap_dance.md | cat
 --> 

-## イントロダクション
+## イントロダクション :id=introduction

 セミコロンキーを1回叩くと、セミコロンが送信されます。2回素早く叩くと、コロンが送信されます。3回叩くと、あなたのキーボードのLEDが激しく踊るように明滅します。これは、タップダンスでできることの一例です。それは、コミュニティが提案したとても素敵なファームウェアの機能の1つで、[algernon](https://github.com/algernon) がプルリクエスト [#451](https://github.com/qmk/qmk_firmware/pull/451) で考えて作ったものです。algernon が述べる機能は次の通りです:

 この機能を使うと、特定のキーが、タップした回数に基づいて異なる振る舞いをします。そして、割り込みがあった時は、割り込み前に上手く処理されます。

-## `ACTION_FUNCTION_TAP` との比較について
-
-`ACTION_FUNCTION_TAP` はタップダンスに似た機能を提供しますが、注目すべきいくつかの重要な違いがあります。違いを確認するため、いくつかの設定を調べてみましょう。1つのキーを1回タップすると `Space` キーが送信され、2回タップすると `Enter` キーが送信されるよう設定します。
-
-`ACTION_FUNCTION_TAP` では、これを設定するのはかなり大変で、キーの順番が割り込まれた時に割り込んだキーが最初に送られるという問題に直面します。例えば、`SPC a` は、もし `SPC` と `a` が `TAPPING_TERM` で設定した時間内に両方とも入力された場合、結果として `a SPC` が送信されます。タップダンス機能を使う場合、正しく `SPC a` が送信されます（`TAPPING_TERM` で設定した時間内に `SPC` と `a` を入力した場合であっても）。
-
-割り込みを正しくハンドリングして目的を達成するため、タップダンスの実装ではシステムの2つの部分をフックします: `process_record_quantum()` とマトリックススキャンです。この2つの部分については以下で説明しますが、今注意すべき点は、マトリックススキャンでは、キーが押されていない時でもタップのシーケンスをタイムアウトにできる必要があるということです。そうすれば、`TAPPING_TERM` の時間が経過した後、`SPC` だけがタイムアウトになって登録されます。
-
-## タップダンスの使い方
-
-一般論は十分です。タップダンスの実際の使い方を見てみましょう！
-
-最初に、あなたの `rules.mk` ファイルで `TAP_DANCE_ENABLE=yes` と設定する必要があります。なぜならば、デフォルトでは無効になっているからです。これでファームウェアのサイズが1キロバイトほど増加します。
+## タップダンスの使い方 :id=how-to-use
+最初に、あなたの `rules.mk` ファイルで `TAP_DANCE_ENABLE = yes` と設定する必要があります。なぜならば、デフォルトでは無効になっているからです。これでファームウェアのサイズが1キロバイトほど増加します。

 オプションで、あなたの `config.h` ファイルに次のような設定を追加して、`TAPPING_TERM` の時間をカスタマイズしたほうが良いです。

-```
+```c
 #define TAPPING_TERM 175
 ```

 `TAPPING_TERM` の時間は、あなたのタップダンスのキーのタップとタップの間の時間として許可された最大の時間で、ミリ秒単位で計測されます。例えば、もし、あなたがこの上にある `#define` ステートメントを使い、1回タップすると `Space` が送信され、2回タップすると `Enter` が送信されるタップダンスキーをセットアップした場合、175ミリ秒以内に2回キーをタップすれば `ENT` だけが送信されるでしょう。もし、1回タップしてから175ミリ秒以上待ってからもう一度タップすると、`SPC SPC` が送信されます。

-次に、いくつかのタップダンスのキーを定義するためには、`TD()` マクロ — `F()` マクロに似ています — を使うのが最も簡単です。これは数字を受け取り、この数字は後で `tap_dance-actions` 配列のインデックスとして使われます。
+次に、いくつかのタップダンスのキーを定義するためには、`TD()` マクロを使うのが最も簡単です。これは数字を受け取り、この数字は後で `tap_dance-actions` 配列のインデックスとして使われます。

 その後、`tap_dance_actions` 配列を使って、タップダンスキーを押した時のアクションを定義します。現在は、5つの可能なオプションがあります:

@ -56,7 +45,7 @@
 最後に、5番目のオプションは、もし、タップダンスキーをコードに追加した後、非タップダンスキーが奇妙な振る舞いを始めた時に特に役に立ちます。ありうる問題は、あなたがタップダンスキーを使いやすくするために `TAPPING_TERM` の時間を変更した結果、その他のキーが割り込みを処理する方法が変わってしまったというものです。


-## 実装の詳細
+## 実装の詳細 :id=implementation

 さて、説明の大部分はここまでです！ 以下に挙げているいくつかの例に取り組むことができるようになり、あなた自身のタップダンスの機能を開発できるようになります。しかし、もし、あなたが裏側で起きていることをより深く理解したいのであれば、続けてそれが全てどのように機能するかの説明を読みましょう！

@ -72,9 +61,9 @@

 柔軟性のために、タップダンスは、キーコードの組み合わせにも、ユーザー関数にもなることができます。後者は、より高度なタップ回数の制御や、LED を点滅させたり、バックライトをいじったり、等々の制御を可能にします。これは、1つの共用体と、いくつかの賢いマクロによって成し遂げられています。

-# 実装例
+## 実装例 :id=examples

-## シンプルな実装例
+### シンプルな実装例 :id=simple-example

 ここに1つの定義のための簡単な例があります。

@ -85,21 +74,24 @@
 ```c
 // タップダンスの宣言
 enum {
-  TD_ESC_CAPS = 0
+    TD_ESC_CAPS,
 };

 // タップダンスの定義
 qk_tap_dance_action_t tap_dance_actions[] = {
-  // 1回タップすると Escape キー、2回タップすると Caps Lock。
-  [TD_ESC_CAPS]  = ACTION_TAP_DANCE_DOUBLE(KC_ESC, KC_CAPS)
-// ほかの宣言もカンマで区切ってここに記述します
+    // 1回タップすると Escape キー、2回タップすると Caps Lock。
+    [TD_ESC_CAPS]  = ACTION_TAP_DANCE_DOUBLE(KC_ESC, KC_CAPS),
 };

-// レイヤー定義で、キーコードの代わりにタップダンスキーを追加します
-TD(TD_ESC_CAPS)
+// キーコードの代わりにタップダンスキーを追加します
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    // ...
+    TD(TD_ESC_CAPS)
+    // ...
+};
 ```

-## 複雑な実装例
+### 複雑な実装例 :id=complex-examples

 このセクションでは、いくつかの複雑なタップダンスの例を詳しく説明します。
 例で使われている全ての列挙型はこのように宣言します。
@ -107,107 +99,104 @@ TD(TD_ESC_CAPS)
 ```c
 // 全ての例のための列挙型定義
 enum {
- CT_SE = 0,
- CT_CLN,
- CT_EGG,
- CT_FLSH,
- X_TAP_DANCE
+    CT_SE,
+    CT_CLN,
+    CT_EGG,
+    CT_FLSH,
+    X_TAP_DANCE
 };
 ```
-### 例1: 1回タップすると `:` を送信し、2回タップすると `;` を送信する
+#### 例1: 1回タップすると `:` を送信し、2回タップすると `;` を送信する :id=example-1

 ```c
-void dance_cln_finished (qk_tap_dance_state_t *state, void *user_data) {
-  if (state->count == 1) {
-    register_code (KC_RSFT);
-    register_code (KC_SCLN);
-  } else {
-    register_code (KC_SCLN);
-  }
+void dance_cln_finished(qk_tap_dance_state_t *state, void *user_data) {
+    if (state->count == 1) {
+        register_code16(KC_COLN);
+    } else {
+        register_code(KC_SCLN);
+    }
 }

-void dance_cln_reset (qk_tap_dance_state_t *state, void *user_data) {
-  if (state->count == 1) {
-    unregister_code (KC_RSFT);
-    unregister_code (KC_SCLN);
-  } else {
-    unregister_code (KC_SCLN);
-  }
+void dance_cln_reset(qk_tap_dance_state_t *state, void *user_data) {
+    if (state->count == 1) {
+        unregister_code16(KC_COLN);
+    } else {
+        unregister_code(KC_SCLN);
+    }
 }

 // 全てのタップダンス関数はここに定義します。ここでは1つだけ示します。
 qk_tap_dance_action_t tap_dance_actions[] = {
- [CT_CLN] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, dance_cln_finished, dance_cln_reset)
+    [CT_CLN] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_cln_finished, dance_cln_reset),
 };
 ```

-### 例2: 100回タップした後に "Safety Dance!" を送信します
+#### 例2: 100回タップした後に "Safety Dance!" を送信します :id=example-2

 ```c
-void dance_egg (qk_tap_dance_state_t *state, void *user_data) {
-  if (state->count >= 100) {
-    SEND_STRING ("Safety dance!");
-    reset_tap_dance (state);
-  }
+void dance_egg(qk_tap_dance_state_t *state, void *user_data) {
+    if (state->count >= 100) {
+        SEND_STRING("Safety dance!");
+        reset_tap_dance(state);
+    }
 }

 qk_tap_dance_action_t tap_dance_actions[] = {
- [CT_EGG] = ACTION_TAP_DANCE_FN (dance_egg)
+    [CT_EGG] = ACTION_TAP_DANCE_FN(dance_egg),
 };
 ```

-### 例3: 1つずつ LED を点灯させてから消灯する
+#### 例3: 1つずつ LED を点灯させてから消灯する :id=example-3

 ```c
 // タップする毎に、LED を右から左に点灯します。
 // 4回目のタップで、右から左に消灯します。
 void dance_flsh_each(qk_tap_dance_state_t *state, void *user_data) {
-  switch (state->count) {
-  case 1:
-    ergodox_right_led_3_on();
-    break;
-  case 2:
-    ergodox_right_led_2_on();
-    break;
-  case 3:
-    ergodox_right_led_1_on();
-    break;
-  case 4:
-    ergodox_right_led_3_off();
-    _delay_ms(50);
-    ergodox_right_led_2_off();
-    _delay_ms(50);
-    ergodox_right_led_1_off();
-  }
+    switch (state->count) {
+        case 1:
+            ergodox_right_led_3_on();
+            break;
+        case 2:
+            ergodox_right_led_2_on();
+            break;
+        case 3:
+            ergodox_right_led_1_on();
+            break;
+        case 4:
+            ergodox_right_led_3_off();
+            wait_ms(50);
+            ergodox_right_led_2_off();
+            wait_ms(50);
+            ergodox_right_led_1_off();
+    }
 }

 // 4回目のタップで、キーボードをフラッシュ状態にセットします。
 void dance_flsh_finished(qk_tap_dance_state_t *state, void *user_data) {
-  if (state->count >= 4) {
-    reset_keyboard();
-    reset_tap_dance(state);
-  }
+    if (state->count >= 4) {
+        reset_keyboard();
+    }
 }

 // もしフラッシュ状態にならない場合、LED を左から右に消灯します。
 void dance_flsh_reset(qk_tap_dance_state_t *state, void *user_data) {
-  ergodox_right_led_1_off();
-  _delay_ms(50);
-  ergodox_right_led_2_off();
-  _delay_ms(50);
-  ergodox_right_led_3_off();
+    ergodox_right_led_1_off();
+    wait_ms(50);
+    ergodox_right_led_2_off();
+    wait_ms(50);
+    ergodox_right_led_3_off();
 }

 // 全てのタップダンス関数を一緒に表示しています。この例3は "CT_FLASH" です。
 qk_tap_dance_action_t tap_dance_actions[] = {
-  [CT_SE]  = ACTION_TAP_DANCE_DOUBLE (KC_SPC, KC_ENT)
- ,[CT_CLN] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, dance_cln_finished, dance_cln_reset)
- ,[CT_EGG] = ACTION_TAP_DANCE_FN (dance_egg)
- ,[CT_FLSH] = ACTION_TAP_DANCE_FN_ADVANCED (dance_flsh_each, dance_flsh_finished, dance_flsh_reset)
+    [CT_SE] = ACTION_TAP_DANCE_DOUBLE(KC_SPC, KC_ENT),
+    [CT_CLN] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_cln_finished, dance_cln_reset),
+    [CT_EGG] = ACTION_TAP_DANCE_FN(dance_egg),
+    [CT_FLSH] = ACTION_TAP_DANCE_FN_ADVANCED(dance_flsh_each, dance_flsh_finished, dance_flsh_reset)
 };
 ```

-### 例4: クアッドファンクションのタップダンス
+#### 例4: クアッドファンクションのタップダンス :id=example-4

 [DanielGGordon](https://github.com/danielggordon) によるもの

@ -219,40 +208,37 @@ qk_tap_dance_action_t tap_dance_actions[] = {
 *  2回タップ = `Escape` を送信
 *  2回タップして押し続ける = `Alt` を送信

-## 準備
-
 'クアッドファンクションのタップダンス' を利用できるようにするには、いくつかのものが必要になります。

 `keymap.c` ファイルの先頭、つまりキーマップの前に、以下のコードを追加します。

 ```c
 typedef struct {
-  bool is_press_action;
-  int state;
+    bool is_press_action;
+    uint8_t state;
 } tap;

 enum {
-  SINGLE_TAP = 1,
-  SINGLE_HOLD = 2,
-  DOUBLE_TAP = 3,
-  DOUBLE_HOLD = 4,
-  DOUBLE_SINGLE_TAP = 5, //シングルタップを2回送信
-  TRIPLE_TAP = 6,
-  TRIPLE_HOLD = 7
+    SINGLE_TAP = 1,
+    SINGLE_HOLD,
+    DOUBLE_TAP,
+    DOUBLE_HOLD,
+    DOUBLE_SINGLE_TAP, // シングルタップを2回送信
+    TRIPLE_TAP,
+    TRIPLE_HOLD
 };

 // タップダンスの列挙型
 enum {
-  X_CTL = 0,
-  SOME_OTHER_DANCE
+    X_CTL,
+    SOME_OTHER_DANCE
 };

-int cur_dance (qk_tap_dance_state_t *state);
-
-//xタップダンスのための関数。キーマップで利用できるようにするため、ここに置きます。
-void x_finished (qk_tap_dance_state_t *state, void *user_data);
-void x_reset (qk_tap_dance_state_t *state, void *user_data);
+uint8_t cur_dance(qk_tap_dance_state_t *state);

+// xタップダンスのための関数。キーマップで利用できるようにするため、ここに置きます。
+void x_finished(qk_tap_dance_state_t *state, void *user_data);
+void x_reset(qk_tap_dance_state_t *state, void *user_data);
 ```

 次に、`keymap.c` ファイルの末尾に、次のコードを追加する必要があります。
@ -288,68 +274,64 @@ void x_reset (qk_tap_dance_state_t *state, void *user_data);
 * 3つ目の点については、'DOUBLE_SINGLE_TAP' が存在しますが、これは完全にはテストされていません
 *
 */
-int cur_dance (qk_tap_dance_state_t *state) {
-  if (state->count == 1) {
-    if (state->interrupted || !state->pressed)  return SINGLE_TAP;
-    //キーは割り込まれていませんが、まだ押し続けられています。'HOLD' を送信することを意味します。
-    else return SINGLE_HOLD;
-  }
-  else if (state->count == 2) {
-    /*
-     * DOUBLE_SINGLE_TAP は "pepper" と入力することと、'pp' と入力したときに実際に
-     * ダブルタップしたい場合とを区別するためのものです。
-     * この戻り値の推奨されるユースケースは、'ダブルタップ' 動作やマクロではなく、
-     * そのキーの2つのキー入力を送信したい場合です。
-    */
-    if (state->interrupted) return DOUBLE_SINGLE_TAP;
-    else if (state->pressed) return DOUBLE_HOLD;
-    else return DOUBLE_TAP;
-  }
-  //誰も同じ文字を3回入力しようとしていないと仮定します(少なくとも高速には)。
-  //タップダンスキーが 'KC_W' で、"www." と高速に入力したい場合、ここに例外を追加して
-  //'TRIPLE_SINGLE_TAP' を返し、'DOUBLE_SINGLE_TAP' のようにその列挙型を定義する
-  //必要があります。
-  if (state->count == 3) {
-    if (state->interrupted || !state->pressed)  return TRIPLE_TAP;
-    else return TRIPLE_HOLD;
-  }
-  else return 8; //マジックナンバー。いつかこのメソッドはより多くの押下に対して機能するよう拡張されるでしょう
+uint8_t cur_dance(qk_tap_dance_state_t *state) {
+    if (state->count == 1) {
+        if (state->interrupted || !state->pressed) return SINGLE_TAP;
+        // キーは割り込まれていませんが、まだ押し続けられています。'HOLD' を送信することを意味します。
+        else return SINGLE_HOLD;
+    } else if (state->count == 2) {
+        // DOUBLE_SINGLE_TAP は "pepper" と入力することと、'pp' と入力したときに実際に
+        // ダブルタップしたい場合とを区別するためのものです。
+        // この戻り値の推奨されるユースケースは、'ダブルタップ' 動作やマクロではなく、
+        // そのキーの2つのキー入力を送信したい場合です。
+        if (state->interrupted) return DOUBLE_SINGLE_TAP;
+        else if (state->pressed) return DOUBLE_HOLD;
+        else return DOUBLE_TAP;
+    }
+
+    // 誰も同じ文字を3回入力しようとしていないと仮定します(少なくとも高速には)。
+    // タップダンスキーが 'KC_W' で、"www." と高速に入力したい場合、ここに例外を追加して
+    // 'TRIPLE_SINGLE_TAP' を返し、'DOUBLE_SINGLE_TAP' のようにその列挙型を定義する必要があります。
+    if (state->count == 3) {
+        if (state->interrupted || !state->pressed) return TRIPLE_TAP;
+        else return TRIPLE_HOLD;
+    } else return 8; // マジックナンバー。いつかこのメソッドはより多くの押下に対して機能するよう拡張されるでしょう
 }

-//'x' タップダンスの 'tap' のインスタンスをインスタンス化します
+//'x' タップダンスの 'tap' のインスタンスを生成します。
 static tap xtap_state = {
-  .is_press_action = true,
-  .state = 0
+    .is_press_action = true,
+    .state = 0
 };

-void x_finished (qk_tap_dance_state_t *state, void *user_data) {
-  xtap_state.state = cur_dance(state);
-  switch (xtap_state.state) {
-    case SINGLE_TAP: register_code(KC_X); break;
-    case SINGLE_HOLD: register_code(KC_LCTRL); break;
-    case DOUBLE_TAP: register_code(KC_ESC); break;
-    case DOUBLE_HOLD: register_code(KC_LALT); break;
-    case DOUBLE_SINGLE_TAP: register_code(KC_X); unregister_code(KC_X); register_code(KC_X);
-    //最後の case は高速入力用です。キーが `f` であると仮定します:
-    //例えば、`buffer` という単語を入力するとき、`Esc` ではなく `ff` を送信するようにします。
-    //高速入力時に `ff` と入力するには、次の文字は `TAPPING_TERM` 以内に入力する必要があります。
-    //`TAPPING_TERM` はデフォルトでは 200ms です。
-  }
+void x_finished(qk_tap_dance_state_t *state, void *user_data) {
+    xtap_state.state = cur_dance(state);
+    switch (xtap_state.state) {
+        case SINGLE_TAP: register_code(KC_X); break;
+        case SINGLE_HOLD: register_code(KC_LCTRL); break;
+        case DOUBLE_TAP: register_code(KC_ESC); break;
+        case DOUBLE_HOLD: register_code(KC_LALT); break;
+        // 最後の case は高速入力用です。キーが `f` であると仮定します:
+        // 例えば、`buffer` という単語を入力するとき、`Esc` ではなく `ff` を送信するようにします。
+        // 高速入力時に `ff` と入力するには、次の文字は `TAPPING_TERM` 以内に入力する必要があります。
+        // `TAPPING_TERM` はデフォルトでは 200ms です。
+        case DOUBLE_SINGLE_TAP: tap_code(KC_X); register_code(KC_X);
+    }
 }

-void x_reset (qk_tap_dance_state_t *state, void *user_data) {
-  switch (xtap_state.state) {
-    case SINGLE_TAP: unregister_code(KC_X); break;
-    case SINGLE_HOLD: unregister_code(KC_LCTRL); break;
-    case DOUBLE_TAP: unregister_code(KC_ESC); break;
-    case DOUBLE_HOLD: unregister_code(KC_LALT);
-    case DOUBLE_SINGLE_TAP: unregister_code(KC_X);
-  }
-  xtap_state.state = 0;
+void x_reset(qk_tap_dance_state_t *state, void *user_data) {
+    switch (xtap_state.state) {
+        case SINGLE_TAP: unregister_code(KC_X); break;
+        case SINGLE_HOLD: unregister_code(KC_LCTRL); break;
+        case DOUBLE_TAP: unregister_code(KC_ESC); break;
+        case DOUBLE_HOLD: unregister_code(KC_LALT);
+        case DOUBLE_SINGLE_TAP: unregister_code(KC_X);
+    }
+    xtap_state.state = 0;
 }

 qk_tap_dance_action_t tap_dance_actions[] = {
-  [X_CTL]     = ACTION_TAP_DANCE_FN_ADVANCED(NULL,x_finished, x_reset)
+    [X_CTL] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, x_finished, x_reset)
 };
 ```

@ -359,90 +341,91 @@ qk_tap_dance_action_t tap_dance_actions[] = {

 > この設定の "hold" は、タップダンスのタイムアウト（`ACTION_TAP_DANCE_FN_ADVANCED_TIME` 参照）の **後** に起こります。即座に "hold" を得るためには、条件から `state->interrupted` の確認を除きます。結果として、複数回のタップのための時間をより多く持つことで快適な長いタップの期限を使うことができ、そして、"hold" のために長く待たないようにすることができます(2倍の `TAPPING TERM` で開始してみてください)。

-### 例5: タップダンスを高度なモッドタップとレイヤータップキーに使う :id=example-5-using-tap-dance-for-advanced-mod-tap-and-layer-tap-keys
+#### 例5: タップダンスを高度なモッドタップとレイヤータップキーに使う :id=example-5

 タップダンスは、タップされたコードが基本的なキーコード以外の場合に、 `MT()` と `LT()` マクロをエミュレートするのに利用できます。これは、通常 `Shift` を必要とする '(' や '{' のようなキーや、`Control + X` のように他の修飾されたキーコードをタップされたキーコードとして送信することに役立ちます。

 あなたのレイヤーとカスタムキーコードの下に、以下のコードを追加します。

 ```c
-//タップダンスのキーコード
-enum td_keycodes { 
-  ALT_LP //例: 押していると `LALT`、タップすると `(`。それぞれのタップダンスの追加のキーコードを追加します
+// タップダンスのキーコード
+enum td_keycodes {
+    ALT_LP // 例: 押していると `LALT`、タップすると `(`。それぞれのタップダンスの追加のキーコードを追加します
 };

-//必要な数のタップダンス状態を含むタイプを定義します
+// 必要な数のタップダンス状態を含むタイプを定義します
 typedef enum {
-  SINGLE_TAP,
-  SINGLE_HOLD,
-  DOUBLE_SINGLE_TAP
+    SINGLE_TAP,
+    SINGLE_HOLD,
+    DOUBLE_SINGLE_TAP
 } td_state_t;

-//タップダンスの状態の型のグローバルインスタンスを作ります
+// タップダンスの状態の型のグローバルインスタンスを作ります
 static td_state_t td_state;

-//タップダンス関数を宣言します:
+// タップダンス関数を宣言します:

-//現在のタップダンスの状態を特定するための関数
-int cur_dance (qk_tap_dance_state_t *state);
+// 現在のタップダンスの状態を特定するための関数
+uint8_t cur_dance(qk_tap_dance_state_t *state);

-//それぞれのタップダンスキーコードに適用する `finished` と `reset` 関数
-void altlp_finished (qk_tap_dance_state_t *state, void *user_data);
-void altlp_reset (qk_tap_dance_state_t *state, void *user_data);
+// それぞれのタップダンスキーコードに適用する `finished` と `reset` 関数
+void altlp_finished(qk_tap_dance_state_t *state, void *user_data);
+void altlp_reset(qk_tap_dance_state_t *state, void *user_data);
 ```

 キーレイアウト（`LAYOUT`）の下に、タップダンスの関数を定義します。

 ```c
 // 返却するタップダンス状態を特定します
-int cur_dance (qk_tap_dance_state_t *state) {
-  if (state->count == 1) {
-    if (state->interrupted || !state->pressed) { return SINGLE_TAP; }
-    else { return SINGLE_HOLD; }
-  }
-  if (state->count == 2) { return DOUBLE_SINGLE_TAP; }
-  else { return 3; } // 上記で返却する最大の状態の値より大きい任意の数
+uint8_t cur_dance(qk_tap_dance_state_t *state) {
+    if (state->count == 1) {
+        if (state->interrupted || !state->pressed) return SINGLE_TAP;
+        else return SINGLE_HOLD;
+    }
+
+    if (state->count == 2) return DOUBLE_SINGLE_TAP;
+    else return 3; // 上記で返却する最大の状態の値より大きい任意の数
 }
- 
+
 // 定義する各タップダンスキーコードのとりうる状態を制御します:

-void altlp_finished (qk_tap_dance_state_t *state, void *user_data) {
-  td_state = cur_dance(state);
-  switch (td_state) {
-    case SINGLE_TAP:
-      register_code16(KC_LPRN);
-      break;
-    case SINGLE_HOLD:
-      register_mods(MOD_BIT(KC_LALT)); // レイヤータップキーの場合、ここでは `layer_on(_MY_LAYER)` を使います
-      break;
-    case DOUBLE_SINGLE_TAP: // タップ時間内に2つの括弧 `((` の入れ子を可能にします
-      tap_code16(KC_LPRN);
-      register_code16(KC_LPRN);
-  }
+void altlp_finished(qk_tap_dance_state_t *state, void *user_data) {
+    td_state = cur_dance(state);
+    switch (td_state) {
+        case SINGLE_TAP:
+            register_code16(KC_LPRN);
+            break;
+        case SINGLE_HOLD:
+            register_mods(MOD_BIT(KC_LALT)); // レイヤータップキーの場合、ここでは `layer_on(_MY_LAYER)` を使います
+            break;
+        case DOUBLE_SINGLE_TAP: // タップ時間内に2つの括弧 `((` の入れ子を可能にします
+            tap_code16(KC_LPRN);
+            register_code16(KC_LPRN);
+    }
 }

-void altlp_reset (qk_tap_dance_state_t *state, void *user_data) {
-  switch (td_state) {
-    case SINGLE_TAP:
-      unregister_code16(KC_LPRN);
-      break;
-    case SINGLE_HOLD:
-      unregister_mods(MOD_BIT(KC_LALT)); // レイヤータップキーの場合、ここでは `layer_off(_MY_LAYER)` を使います
-      break;
-    case DOUBLE_SINGLE_TAP:
-      unregister_code16(KC_LPRN);
-  }
+void altlp_reset(qk_tap_dance_state_t *state, void *user_data) {
+    switch (td_state) {
+        case SINGLE_TAP:
+            unregister_code16(KC_LPRN);
+            break;
+        case SINGLE_HOLD:
+            unregister_mods(MOD_BIT(KC_LALT)); // レイヤータップキーの場合、ここでは `layer_off(_MY_LAYER)` を使います
+            break;
+        case DOUBLE_SINGLE_TAP:
+            unregister_code16(KC_LPRN);
+    }
 }

 // 各タップダンスキーコードの `ACTION_TAP_DANCE_FN_ADVANCED()` を定義し、`finished` と `reset` 関数を渡します
 qk_tap_dance_action_t tap_dance_actions[] = {
-  [ALT_LP] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, altlp_finished, altlp_reset)
+    [ALT_LP] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, altlp_finished, altlp_reset)
 };
 ```

 それぞれのタップダンスキーコードをキーマップに含めるときは、`TD()` マクロでキーコードをラップします。例: `TD(ALT_LP)`

-### 例6: タップダンスを一時的なレイヤー切り替えとレイヤートグルキーに使う
+#### 例6: タップダンスを一時的なレイヤー切り替えとレイヤートグルキーに使う :id=example-6

 タップダンスは、MO(layer) と TG(layer) 機能を模倣することにも使用できます。この例では、1回タップすると `KC_QUOT` 、1回押してそのまま押し続けたら `MO(_MY_LAYER)` 、2回タップしたときは `TG(_MY_LAYER)` として機能するキーを設定します。

@ -450,98 +433,93 @@ qk_tap_dance_action_t tap_dance_actions[] = {

 ```c
 typedef struct {
-  bool is_press_action;
-  int state;
+    bool is_press_action;
+    uint8_t state;
 } tap;

-//必要な数のタップダンス状態のタイプを定義します
+// 必要な数のタップダンス状態のタイプを定義します
 enum {
-  SINGLE_TAP = 1,
-  SINGLE_HOLD = 2,
-  DOUBLE_TAP = 3
+    SINGLE_TAP = 1,
+    SINGLE_HOLD,
+    DOUBLE_TAP
 };

 enum {
-  QUOT_LAYR = 0  //カスタムタップダンスキー。他のタップダンスキーはこの列挙型に追加します
+    QUOT_LAYR, // カスタムタップダンスキー。他のタップダンスキーはこの列挙型に追加します
 };

-//タップダンスキーで使われる関数を宣言します
+// タップダンスキーで使われる関数を宣言します

-//全てのタップダンスに関連する関数
-int cur_dance (qk_tap_dance_state_t *state);
+// 全てのタップダンスに関連する関数
+uint8_t cur_dance(qk_tap_dance_state_t *state);

-//個別のタップダンスに関連する関数
-void ql_finished (qk_tap_dance_state_t *state, void *user_data);
-void ql_reset (qk_tap_dance_state_t *state, void *user_data);
+// 個別のタップダンスに関連する関数
+void ql_finished(qk_tap_dance_state_t *state, void *user_data);
+void ql_reset(qk_tap_dance_state_t *state, void *user_data);
 ```

 あなたの `keymap.c` ファイルの最後の方に以下のコードを追加します。

 ```c
-//現在のタップダンスの状態を決定します
-int cur_dance (qk_tap_dance_state_t *state) {
-  if (state->count == 1) {
-    if (!state->pressed) {
-      return SINGLE_TAP;
-    } else {
-      return SINGLE_HOLD;
-    }
-  } else if (state->count == 2) {
-    return DOUBLE_TAP;
-  }
-  else return 8;
+// 現在のタップダンスの状態を決定します
+uint8_t cur_dance(qk_tap_dance_state_t *state) {
+    if (state->count == 1) {
+        if (!state->pressed) return SINGLE_TAP;
+        else return SINGLE_HOLD;
+    } else if (state->count == 2) return DOUBLE_TAP;
+    else return 8;
 }

-//この例のタップダンスキーに関連付けられた "tap" 構造体を初期化します
+// この例のタップダンスキーに関連付けられた "tap" 構造体を初期化します
 static tap ql_tap_state = {
-  .is_press_action = true,
-  .state = 0
+    .is_press_action = true,
+    .state = 0
 };

-//タップダンスキーの動作をコントロールする関数
-void ql_finished (qk_tap_dance_state_t *state, void *user_data) {
-  ql_tap_state.state = cur_dance(state);
-  switch (ql_tap_state.state) {
-    case SINGLE_TAP: 
-      tap_code(KC_QUOT); 
-      break;
-    case SINGLE_HOLD: 
-      layer_on(_MY_LAYER); 
-      break;
-    case DOUBLE_TAP: 
-      //レイヤーが既にセットされているか確認します
-      if (layer_state_is(_MY_LAYER)) {
-        //レイヤーが既にセットされていたら、オフにします。
+// タップダンスキーの動作をコントロールする関数
+void ql_finished(qk_tap_dance_state_t *state, void *user_data) {
+    ql_tap_state.state = cur_dance(state);
+    switch (ql_tap_state.state) {
+        case SINGLE_TAP:
+            tap_code(KC_QUOT);
+            break;
+        case SINGLE_HOLD:
+            layer_on(_MY_LAYER);
+            break;
+        case DOUBLE_TAP:
+            // レイヤーが既にセットされているか確認します
+            if (layer_state_is(_MY_LAYER)) {
+                // レイヤーが既にセットされていたら、オフにします。
+                layer_off(_MY_LAYER);
+            } else {
+                // レイヤーがセットされていなかったら、オンにします。
+                layer_on(_MY_LAYER);
+            }
+            break;
+    }
+}
+
+void ql_reset(qk_tap_dance_state_t *state, void *user_data) {
+    // キーを押し続けていて今離したら、レイヤーをオフに切り替えます。
+    if (ql_tap_state.state == SINGLE_HOLD) {
        layer_off(_MY_LAYER);
-      } else { 
-        //レイヤーがセットされていなかったら、オンにします。
-        layer_on(_MY_LAYER);
-      }
-      break;
-  }
+    }
+    ql_tap_state.state = 0;
 }

-void ql_reset (qk_tap_dance_state_t *state, void *user_data) {
-  //キーを押し続けていて今離したら、レイヤーをオフに切り替えます。
-  if (ql_tap_state.state==SINGLE_HOLD) {
-    layer_off(_MY_LAYER);
-  }
-  ql_tap_state.state = 0;
-}
-
-//タップダンスキーを機能に関連付けます
+// タップダンスキーを機能に関連付けます
 qk_tap_dance_action_t tap_dance_actions[] = {
-  [QUOT_LAYR] = ACTION_TAP_DANCE_FN_ADVANCED_TIME(NULL, ql_finished, ql_reset, 275)
+    [QUOT_LAYR] = ACTION_TAP_DANCE_FN_ADVANCED_TIME(NULL, ql_finished, ql_reset, 275)
 };
 ```

-上記のコードは、前の例で使われたコードに似ています。注意する1つのポイントは、必要に応じてレイヤーを切り替えられるように、どのレイヤーがアクティブになっているかいつでも確認できる必要があることです。これを実現するために、引数で与えられた `layer` がアクティブなら `true` を返す `layer_state_is( layer )`  を使います。
+上記のコードは、前の例で使われたコードに似ています。注意する1つのポイントは、必要に応じてレイヤーを切り替えられるように、どのレイヤーがアクティブになっているかいつでも確認できる必要があることです。これを実現するために、引数で与えられた `layer` がアクティブなら `true` を返す `layer_state_is(layer)` を使います。

 `cur_dance()` と `ql_tap_state` の使い方は、上の例と似ています。

-`ql_finished` 関数における `case:SINGLE_TAP` は、上の例と似ています。`case:SINGLE_HOLD` は、`ql_reset()` と連動してタップダンスキーを押している間 `_MY_LAYER` に切り替わり、キーを離した時に `_MY_LAYER` から離れます。これは、`MO(_MY_LAYER)` に似ています。`case:DOUBLE_TAP` は、`_MY_LAYER` がアクティブレイヤーかどうかを確認することによって動きます。そして、その結果に基づいてレイヤーのオン・オフをトグルします。これは `TG(_MY_LAYER)` に似ています。
+`ql_finished` 関数における `case:SINGLE_TAP` は、上の例と似ています。`SINGLE_HOLD` の case では、`ql_reset()` と連動してタップダンスキーを押している間 `_MY_LAYER` に切り替わり、キーを離した時に `_MY_LAYER` から離れます。これは、`MO(_MY_LAYER)` に似ています。`DOUBLE_TAP` の case では、`_MY_LAYER` がアクティブレイヤーかどうかを確認することによって動きます。そして、その結果に基づいてレイヤーのオン・オフをトグルします。これは `TG(_MY_LAYER)` に似ています。

 `tap_dance_actions[]` は、上の例に似ています。 `ACTION_TAP_DANCE_FN_ADVANCED()` の代わりに `ACTION_TAP_DANCE_FN_ADVANCED_TIME()` を使ったことに注意してください。
 この理由は、私は、非タップダンスキーを使うにあたり `TAPPING_TERM` が短い(175ミリ秒以内)方が好きなのですが、タップダンスのアクションを確実に完了させるには短すぎるとわかったからです——そのため、ここでは時間を275ミリ秒に増やしています。

-最後に、このタップダンスキーを動かすため、忘れずに `TD(QUOT_LAYR)` を `keymaps[]` に加えてください。 
+最後に、このタップダンスキーを動かすため、忘れずに `TD(QUOT_LAYR)` を `keymaps[]` に加えてください。
--- a/docs/ja/feature_userspace.md
+++ b/docs/ja/feature_userspace.md
@ -1,8 +1,8 @@
 # ユーザスペース: キーマップ間でのコードの共有

 <!---
-  original document: 0.9.0:docs/feature_userspace.md
-  git diff 0.9.0 HEAD -- docs/feature_userspace.md | cat
+  original document: 0.9.43:docs/feature_userspace.md
+  git diff 0.9.43 HEAD -- docs/feature_userspace.md | cat
 -->

 似たキーマップを複数のキーボードで使う場合、それらの間でコードを共有できるという利点が得られることがあります。`users/`に以下の構造でキーマップ(理想的には GitHub のユーザ名、`<name>`)と同じ名前の独自のフォルダを作成します:
@ -116,7 +116,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.

 ## 例

-簡単な例については、[`/users/_example/`](https://github.com/qmk/qmk_firmware/tree/master/users/drashna) を調べてください。
+簡単な例については、[`/users/_example/`](https://github.com/qmk/qmk_firmware/tree/master/users/_example) を調べてください。
 より複雑な例については、[`/users/drashna/`](https://github.com/qmk/qmk_firmware/tree/master/users/drashna) のユーザスペースを調べてください。


--- a/docs/ja/flashing_bootloadhid.md
+++ b/docs/ja/flashing_bootloadhid.md
@ -0,0 +1,75 @@
+# BootloadHID の書き込み手順とブートローダの情報
+
+<!---
+  original document: 0.9.32:docs/flashing_bootloadhid.md
+  git diff 0.9.32 HEAD -- docs/flashing_bootloadhid.md | cat
+-->
+
+ps2avr(GB) キーボードは ATmega32A マイクロコントローラを使い、異なるブートローダを使います。それは通常の QMK の方法を使って書き込むことができません。
+
+一般的な書き込みシーケンス:
+
+1. 以下のいずれかの方法を使ってブートローダに入ります:
+   * `RESET` キーコードをタップします (全てのデバイスでは動作しないかもしれません)
+   * ソルトキーを押し続けながらキーボードを接続します (通常はキーボードの readme に書かれています)
+2. OS がデバイスを検知するのを待ちます。
+3. .hex ファイルを書き込みます
+4. デバイスをアプリケーションモードにリセットします(自動的に実行されるかもしれません)
+
+## bootloadHID の書き込みターゲット
+
+?> [こちら](ja/newbs_getting_started.md)で詳しく説明されている QMK インストールスクリプトを使うと、必要な bootloadHID ツールが自動的にインストールされます。
+
+コマンドライン経由で書き込むには、以下のコマンドを実行してターゲット `:bootloadHID` を使います:
+
+    make <keyboard>:<keymap>:bootloadHID
+
+## GUI 書き込み
+
+### Windows
+1. [HIDBootFlash](http://vusb.wikidot.com/project:hidbootflash) をダウンロードします。
+2. キーボードをリセットします。
+3. 設定された VendorID が `16c0` で、ProductID が `05df` であることを確認します
+4. `Find Device` ボタンを押し、キーボードが見つかることを確認します。
+5. `Open .hex File` ボタンを押し、作成した `.hex` ファイルを見つけます。
+6. `Flash Device` ボタンを押し、処理が完了するまで待ちます。
+
+## コマンドライン書き込み
+
+1. キーボードをリセットします。
+2. `bootloadHID -r` に続けて `.hex` ファイルへのパスを入力し、キーボードに書き込みます。
+
+### Windows 手動インストール
+MSYS2の場合:
+1. https://www.obdev.at/downloads/vusb/bootloadHID.2012-12-08.tar.gz から BootloadHID ファームウェアパッケージをダウンロードします。
+2. 互換性のあるツール、例えば 7-Zip を使って内容を抽出します。
+3. 解凍された書庫から MSYS2 インストール先、通常 `C:\msys64\usr\bin` に `commandline/bootloadHID.exe` をコピーして、MSYS パスに追加します。
+
+ネイティブの Windows 書き込みの場合、MSYS2 環境の外部で `bootloadHID.exe` を使うことができます。
+
+### Linux 手動インストール
+1. libusb development の依存関係をインストールします:
+   ```bash
+   # これは OS に依存します - Debian については以下で動作します
+sudo apt-get install libusb-dev
+   ```
+2. BootloadHID ファームウェアパッケージをダウンロードします:
+   ```
+   wget https://www.obdev.at/downloads/vusb/bootloadHID.2012-12-08.tar.gz -O - | tar -xz -C /tmp
+   ```
+3. bootloadHID 実行可能ファイルをビルドします:
+   ```
+   cd /tmp/bootloadHID.2012-12-08/commandline/
+make
+sudo cp bootloadHID /usr/local/bin
+   ```
+
+### MacOS 手動インストール
+1. 以下を入力して Homebrew をインストールします:
+   ```
+   /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
+   ```
+2. 以下のパッケージをインストールします:
+   ```
+   brew install --HEAD https://raw.githubusercontent.com/robertgzr/homebrew-tap/master/bootloadhid.rb
+   ```
--- a/docs/ja/getting_started_docker.md
+++ b/docs/ja/getting_started_docker.md
@ -0,0 +1,52 @@
+# Docker クイックスタート
+
+<!---
+  original document: 0.9.32:docs/getting_started_docker.md
+  git diff 0.9.32 HEAD -- docs/getting_started_docker.md | cat
+-->
+
+このプロジェクトは、プライマリオペレーティングシステムに大きな変更を加えることなくキーボードの新しいファームウェアを非常に簡単に構築することができる Docker ワークフローを含みます。これは、あなたがプロジェクトをクローンしビルドを実行した時に、他の人とまったく同じ環境と QMK ビルド基盤を持つことも保証します。これにより、人々はあなたが遭遇した問題の解決をより簡単に行えるようになります。
+
+## 必要事項
+
+主な前提条件は動作する `docker` がインストールされていることです。
+* [Docker CE](https://docs.docker.com/install/#supported-platforms)
+
+## 使い方
+
+(サブモジュールを含む) QMK のレポジトリのローカルコピーを取得する:
+
+```bash
+git clone --recurse-submodules https://github.com/qmk/qmk_firmware.git
+cd qmk_firmware
+```
+
+キーマップをビルドするために以下のコマンドを実行します:
+```bash
+util/docker_build.sh <keyboard>:<keymap>
+# 例えば: util/docker_build.sh planck/rev6:default
+```
+
+これは目的のキーボード/キーマップをコンパイルし、結果として書き込み用に `.hex` あるいは `.bin` ファイルを QMK ディレクトリの中に残します。`:keymap` が省略された場合は全てのキーマップが使われます。パラメータの形式は、`make` を使ってビルドする時と同じであることに注意してください。
+
+`target` を指定して Docker から直接キーボードをビルドし、_かつ_書き込むためのサポートもあります。
+
+```bash
+util/docker_build.sh keyboard:keymap:target
+# 例えば: util/docker_build.sh planck/rev6:default:flash
+```
+
+スクリプトをパラメータ無しで開始することもできます。この場合、1つずつビルドパラメータを入力するように求められます。これが使いやすいと思うかもしれません:
+
+```bash
+util/docker_build.sh
+# パラメータを入力として読み込みます (空白にすると全てのキーボード/キーマップ)
+```
+
+## FAQ
+
+### なぜ Windows/macOS 上で書き込めないのですか？
+
+Windows と macOS では、実行するために [Docker Machine](http://gw.tnode.com/docker/docker-machine-with-usb-support-on-windows-macos/) が必要です。これはセットアップが面倒なので、お勧めではありません: 代わりに [QMK Toolbox](https://github.com/qmk/qmk_toolbox) を使ってください。
+
+!> Docker for Windows は[Hyper-V](https://docs.microsoft.com/en-us/virtualization/hyper-v-on-windows/quick-start/enable-hyper-v) を有効にする必要があります。これは、Windows 7、Windows 8 および **Windows 10 Home** のような Hyper-V を搭載していない Windows のバージョンでは機能しないことを意味します。
--- a/docs/ja/getting_started_github.md
+++ b/docs/ja/getting_started_github.md
@ -1,8 +1,8 @@
 # QMK で GitHub を使う方法

 <!---
-  original document: 0.8.82:docs/getting_started_github.md
-  git diff 0.8.82 HEAD -- docs/getting_started_github.md | cat
+  original document: 0.9.43:docs/getting_started_github.md
+  git diff 0.9.43 HEAD -- docs/getting_started_github.md | cat
 -->

 GitHub は慣れていない人には少し注意が必要です - このガイドは、QMK におけるフォーク、クローン、プルリクエストのサブミットの各ステップについて説明します。
@ -11,11 +11,11 @@ GitHub は慣れていない人には少し注意が必要です - このガイ

 [QMK GitHub ページ](https://github.com/qmk/qmk_firmware)を開くと、右上に "Fork" というボタンが見えます:

-![Git でのフォーク](http://i.imgur.com/8Toomz4.jpg)
+![GitHub でのフォーク](http://i.imgur.com/8Toomz4.jpg)

 あなたが組織の一員である場合は、どのアカウントにフォークするかを選択する必要があります。ほとんどの場合、あなたの個人のアカウントにフォークしたいでしょう。フォークが完了したら(しばらく時間が掛かる場合があります)、"Clone or Download" ボタンをクリックします:

-![Git からダウンロード](http://i.imgur.com/N1NYcSz.jpg)
+![GitHub からダウンロード](http://i.imgur.com/N1NYcSz.jpg)

 必ず "HTTPS" を選択し、リンクを選択してコピーします:

--- a/docs/ja/hardware_avr.md
+++ b/docs/ja/hardware_avr.md
@ -73,7 +73,7 @@ or open the directory in your favourite text editor.

 `config.h` の先頭には USB に関する設定があります。これらはキーボードが OS からどのように見えるかを制御しています。変更する理由がない場合は、`VENDOR_ID` を `0xFEED` のままにしておく必要があります。`PRODUCT_ID` にはまだ使用されていない番号を選ばなければいけません。

-`MANUFACTURER`、 `PRODUCT`、 `DESCRIPTION` をキーボードにあった設定に変更します。
+`MANUFACTURER`、 `PRODUCT` をキーボードにあった設定に変更します。

 ```c
 #define VENDOR_ID       0xFEED
@ -81,7 +81,6 @@ or open the directory in your favourite text editor.
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    You
 #define PRODUCT         my_awesome_keyboard
-#define DESCRIPTION     A custom keyboard
 ```

 ?> Windows や macOS では、`MANUFACTURER` と `PRODUCT` が USBデバイスのリストに表示されます。Linux 上の `lsusb` では、代わりにデフォルトで [USB ID Repository](http://www.linux-usb.org/usb-ids.html) によって維持されているリストからこれらを取得します。`lsusb -v` を使用するとデバイスから示された値を表示します。また、接続したときのカーネルログにも表示されます。
--- a/docs/ja/how_a_matrix_works.md
+++ b/docs/ja/how_a_matrix_works.md
@ -0,0 +1,104 @@
+# キーボードマトリックスの仕組み
+
+<!---
+  original document: 0.9.32:docs/how_a_matrix_works.md
+  git diff 0.9.32 HEAD -- docs/how_a_matrix_works.md | cat
+-->
+
+キーボードスイッチのマトリックスは行と列に配置されます。マトリックス回路がなければ、各スイッチはコントローラに直接配線する必要があります。
+
+回路が行と列に配置されている場合、キーが押されると、列ワイヤが行ワイヤと接触し、回路が完成します。キーボードコントローラはこの閉回路を検知し、キー押下として登録します。
+
+マイクロコントローラはファームウェアを介してセットアップされ、論理1を一度に1つずつ列に送信し、行から一度に全てを読み取ります - このプロセスはマトリックススキャンと呼ばれます。マトリックスはデフォルトでは電流の通過を許可しないたくさんの開いたスイッチです - ファームウェアはキーが押されていないものとしてこれを読み取ります。1つのキーを押すとすぐに、キースイッチが接続されている列から来ていた論理1がスイッチを通過して対応する行に渡されます - 以下の 2x2 の例を確認してください:
+
+        Column 0 being scanned     Column 1 being scanned
+                  x                                   x
+                 col0     col1              col0     col1
+                  |        |                 |        |
+        row0 ---(key0)---(key1)    row0 ---(key0)---(key1)
+                  |        |                 |        |
+        row1 ---(key2)---(key3)    row1 ---(key2)---(key3)
+
+`x` は関連付けられた列と行の値が1であるか、HIGH であることを表します。ここでは、キーが押されていないことが分かります。そのため `x` を取得する行はありません。1つのキースイッチの二つの接点はそのスイッチのある行と列にそれぞれ接続されていることに注意してください。
+
+`key0` を押すと、`col0` は `row0` に接続されるため、ファームウェアがその行に対して受け取る値は `0b01` です (ここで `0b` はこれがビット値であることを意味します。つまり次の数字は全てビット(0または1)であり、その列のキーを表します)。この表記を使用して、キースイッチが押されたことを示し、列と行が接続されていることを示します:
+
+        Column 0 being scanned     Column 1 being scanned
+                  x                                   x
+                 col0     col1              col0     col1
+                  |        |                 |        |
+      x row0 ---(-+-0)---(key1)    row0 ---(-+-0)---(key1)
+                  |        |                 |        |
+        row1 ---(key2)---(key3)    row1 ---(key2)---(key3)
+
+`row0` には `x` があるため、値が1であることがわかります。全体として、`key0` が押された時にファームウェアが受信するデータは、
+
+    col0: 0b01
+    col1: 0b00
+            │└row0
+            └row1
+
+一度に複数のキーを押し始めると問題が発生します。マトリックスをもう一度見ると、かなり明白になっているはずです:
+
+        Column 0 being scanned     Column 1 being scanned
+                  x                                   x
+                 col0     col1              col0     col1
+                  |        |                 |        |
+      x row0 ---(-+-0)---(-+-1)  x row0 ---(-+-0)---(-+-1)
+                  |        |                 |        |
+      x row1 ---(key2)---(-+-3)  x row1 ---(key2)---(-+-3)
+
+      Remember that this ^ is still connected to row1
+
+これから取得されるデータは以下の通りです:
+
+    col0: 0b11
+    col1: 0b11
+            │└row0
+            └row1
+
+4つ全てではなく、3つのキーしか押されていないため、これは正確ではありません。この挙動はゴーストと呼ばれ、このような奇妙なシナリオでのみ発生しますが、より大きなキーボードではより一般的です。これを回避する方法は、キースイッチの後に、行に接続する前にダイオードを配置することです。ダイオードは、電流が一方向にのみ流れるようにします。これにより、前の例で他の列と行がアクティブにならないようにします。ダイオードマトリックスをこのように表します;
+
+        Column 0 being scanned     Column 1 being scanned
+                    x                                   x
+                  col0      col1              col0     col1
+                    │        │                 |        │
+                 (key0)   (key1)            (key0)   (key1)
+                  ! │      ! │               ! |      ! │
+        row0 ─────┴────────┘ │     row0 ─────┴────────┘ │
+                    │        │                 |        │
+                 (key2)   (key3)            (key2)   (key3)
+                  !        !                 !        !
+        row1 ─────┴────────┘       row1 ─────┴────────┘
+
+実際の用途では、ダイオードの黒い線が行に面するように、キースイッチから離れるように配置されます - この場合の `!` はダイオードで、隙間は黒い線を表します。これを覚える良い方法は、以下のシンボルを考えることです: `>|`
+
+次に、3つのキーを押して、ゴーストシナリオとなるものを実施します:
+
+        Column 0 being scanned     Column 1 being scanned
+                    x                                   x
+                  col0      col1              col0     col1
+                    │        │                 │        │
+                 (┌─┤0)   (┌─┤1)            (┌─┤0)   (┌─┤1)
+                  ! │      ! │               ! │      ! │
+      x row0 ─────┴────────┘ │   x row0 ─────┴────────┘ │
+                    │        │                 │        │
+                 (key2)   (┌─┘3)            (key2)   (┌─┘3)
+                  !        !                 !        !
+        row1 ─────┴────────┘     x row1 ─────┴────────┘
+
+全てが期待通りに動きます！これにより、以下のデータが取得されます:
+
+    col0: 0b01
+    col1: 0b11
+            │└row0
+            └row1
+
+ファームウェアはこの正しいデータを使って、何をすべきかを、最終的には OS に送信する必要のある信号を検出できます。
+
+参考文献:
+- [Wikipedia の記事](https://en.wikipedia.org/wiki/Keyboard_matrix_circuit)
+- [Deskthority の記事](https://deskthority.net/wiki/Keyboard_matrix)
+- [Dave Dribin による Keyboard Matrix Help (2000)](https://www.dribin.org/dave/keyboard/one_html/)
+- [PCBheaven による How Key Matrices Works](http://pcbheaven.com/wikipages/How_Key_Matrices_Works/) (アニメーションの例)
+- [キーボードの仕組み - QMK ドキュメント](how_keyboards_work.md)
--- a/docs/ja/how_keyboards_work.md
+++ b/docs/ja/how_keyboards_work.md
@ -0,0 +1,74 @@
+# キーが登録され、コンピュータで解釈される仕組み
+
+<!---
+  original document: 0.9.32:docs/how_keyboards_work.md
+  git diff 0.9.32 HEAD -- docs/how_keyboards_work.md | cat
+-->
+
+このファイルでは、USB を介してキーボードがどのように動作するかの概念を学習できます。ファームウェアを直接変更することで何が期待できるかをより良く理解することができます。
+
+## 概略図
+
+特定のキーを1つ入力するたびに、このような一連のアクションが発生します:
+
+```text
+------+         +-----+       +----------+      +----------+     +----+
+| User |-------->| Key |------>| Firmware |----->| USB wire |---->| OS |
+------+         +-----+       +----------+      +----------+     +----+
+```
+
+この図は何が起こっているかを非常に単純に示したものです。詳細については次のセクションで説明します。
+
+## 1. キーを押す
+
+キーを押すたびに、キーボードのファームウェアはこのイベントを登録することができます。
+キーが押され、保持され、放された時に登録することができます。
+
+これは通常キー押下の定期的な走査で発生します。多くの場合、キーの機械的な応答時間、キー押下情報を転送するプロトコル(ここでは USB HID)、あるいは使用されるソフトウェアによって、この速度は制限されます。
+
+## 2. ファームウェアが送信するもの
+
+[HID 仕様](https://www.usb.org/sites/default/files/documents/hut1_12v2.pdf)では、適切に認識されるためにキーボードが USB 経由で実際に送信できるものを規定しています。これには、`0x00` から `0xE7` までの単純な数字であるスキャンコードの定義済リストが含まれます。ファームウェアはスキャンコードをキーボードのそれぞれのキーに割り当てます。
+
+ファームウェアは実際の文字を送信せず、スキャンコードだけを送信します。
+従って、ファームウェアを変更することで、特定のキーにたいして USB を介してどのスキャンコードが送信されるかだけを変更することができます。
+
+## 3. イベント入力やカーネルが行うこと
+
+*スキャンコード*は、[マスターブランチの 60-keyboard.hwdb](https://github.com/systemd/systemd/blob/master/hwdb.d/60-keyboard.hwdb) キーボードに依存する*キーコード*にマップされます。このマッピングが無いと、オペレーティングシステムは有効なキーコードを受信せず、キー押下で何も有用なことができません。
+
+## 4. オペレーティングシステムがすること
+
+キーコードがオペレーティングシステムに到達すると、ソフトウェアの一部はキーボードのレイアウトによって、実際の文字と照合しなければなりません。例えば、レイアウトが QWERTY に設定されている場合、照合テーブルの例は以下の通りです:
+
+| キーコード | 文字 |
+|---------|-----------|
+| 0x04 | a/A |
+| 0x05 | b/B |
+| 0x06 | c/C |
+| ... | ... |
+| 0x1C | y/Y |
+| 0x1D | z/Z |
+| ... | ... |
+
+## 説明をファームウェアに戻して
+
+(独自のものを作成していない限り)レイアウトは一般的に固定されているため、ファームウェアは実際には作業を簡単するためレイアウト名で直接キーコードを記述できます。これが、`KC_A` が実際に QWERTY で `0x04` を表す場合に行われることです。完全なリストは[キーコード](ja/keycodes.md)にあります。
+
+## 送信できる文字のリスト
+
+ショートカットを別として、限られたキーコードのセットが限られたレイアウトにマップされていることは、**指定されたキーに割り当てることができる文字のリストは、レイアウト内に存在するものだけである**ことを意味します。
+
+例えば、QWERTY US レイアウトがあり、1つのキーを `€` (ユーロ通貨記号)を生成するように割り当てたい場合、そうすることができないことを意味します。なぜなら、QWERTY US レイアウトはそのようなマッピングを持たないためです。QWERTY UK レイアウト、あるいは QWERTY US International を使うことでそれを修正することができます。
+
+全ての Unicode を含むキーボードレイアウトがなぜ考案されていないのか疑問に思うかもしれません。USB を介して利用可能なキーコードの数の制限により、このようなことは許可されません。
+
+## (おそらく) Unicode 文字を入力する方法
+
+ファームウェアに *一連のキー* を送信させて、目的のオペレーティングシステムの[ソフトウェア Unicode インプットメソッド](https://en.wikipedia.org/wiki/Unicode_input#Hexadecimal_input)を使うことができます。このようにして、OS で定義されたレイアウトとは無関係に文字を効率的に入力することができます。
+
+ただし、以下のような複数の欠点があります:
+
+- 一度に、一つの特定の OS に縛られます (OS を変更する時に再コンパイルする必要があります);
+- 特定の OS では、全てのソフトウェアが動作するわけではありません;
+- 一部のシステムでは Unicode のサブセットに制限されます。
--- a/docs/ja/internals_gpio_control.md
+++ b/docs/ja/internals_gpio_control.md
@ -0,0 +1,28 @@
+# GPIO 制御 :id=gpio-control
+
+<!---
+  original document: 0.9.34:docs/internals_gpio_control.md
+  git diff 0.9.34 HEAD -- docs/internals_gpio_control.md | cat
+-->
+
+QMK には、マイクロコントローラに依存しない GPIO 制御抽象レイヤーがあります。これは異なるプラットフォーム間でピン制御に簡単にアクセスできるようにするためのものです。
+
+## 関数 :id=functions
+
+以下の関数は GPIO の基本的な制御を提供し、`quantum/quantum.h` にあります。
+
+| 関数 | 説明 | 古い AVR の例 | 古い ChibiOS/ARM の例 |
+|------------------------|--------------------------------------------------|-------------------------------------------------|-------------------------------------------------|
+| `setPinInput(pin)` | ピンを高インピーダンス(High-Z)の入力として設定 | `DDRB &= ~(1<<2)` | `palSetLineMode(pin, PAL_MODE_INPUT)` |
+| `setPinInputHigh(pin)` | ピンを組み込みのプルアップ抵抗付きの入力として設定 | `DDRB &= ~(1<<2); PORTB \|= (1<<2)` | `palSetLineMode(pin, PAL_MODE_INPUT_PULLUP)` |
+| `setPinInputLow(pin)` | ピンを組み込みのプルダウン抵抗付きの入力として設定 | N/A (AVR ではサポートされません) | `palSetLineMode(pin, PAL_MODE_INPUT_PULLDOWN)` |
+| `setPinOutput(pin)` | ピンを出力として設定 | `DDRB \|= (1<<2)` | `palSetLineMode(pin, PAL_MODE_OUTPUT_PUSHPULL)` |
+| `writePinHigh(pin)` | ピンレベルを high に設定 (ピンを出力として設定してあると仮定) | `PORTB \|= (1<<2)` | `palSetLine(pin)` |
+| `writePinLow(pin)` | ピンレベルを low に設定 (ピンを出力として設定してあると仮定) | `PORTB &= ~(1<<2)` | `palClearLine(pin)` |
+| `writePin(pin, level)` | ピンレベルを設定 (ピンを出力として設定してあると仮定) | `(level) ? PORTB \|= (1<<2) : PORTB &= ~(1<<2)` | `(level) ? palSetLine(pin) : palClearLine(pin)` |
+| `readPin(pin)` | ピンのレベルを返す | `_SFR_IO8(pin >> 4) & _BV(pin & 0xF)` | `palReadLine(pin)` |
+| `togglePin(pin)` | ピンレベルを反転 (ピンを出力として設定してあると仮定) | `PORTB ^= (1<<2)` | `palToggleLine(pin)` |
+
+## 高度な設定 :id=advanced-settings
+
+各マイクロコントローラは GPIO に関して複数の高度な設定を持つことができます。この抽象レイヤーは、アーキテクチャー固有の機能の使用法を制限しません。上級ユーザは、目的のデバイスのデータシートを参照し、必要なライブラリを含めてください。AVR については、標準 avr/io.h ライブラリが使われます; STM32 については ChibiOS [PAL ライブラリ](http://chibios.sourceforge.net/docs3/hal/group___p_a_l.html)が使われます。
--- a/docs/ja/keymap.md
+++ b/docs/ja/keymap.md
@ -1,8 +1,8 @@
 # キーマップの概要

 <!---
-  original document: 0.8.62:docs/keymap.md
-  git diff 0.8.62 HEAD -- docs/keymap.md | cat
+  original document: 0.9.44:docs/keymap.md
+  git diff 0.9.44 HEAD -- docs/keymap.md | cat
 -->

 QMK のキーマップは C のソースファイルの中で定義されます。そのデータ構造は配列の配列です。外側はレイヤーを要素とする配列で、レイヤーはキーを要素とする配列。ほとんどのキーボードは `LAYOUT()` マクロを定義して、この配列の配列を作成しやすくしています。
@ -76,10 +76,22 @@ TMK の歴史的経緯から、キーマップに保存されたアクション


 ### レイヤーの優先順位と透過性
-***上位のレイヤーはレイヤーのスタックでより高い優先順位を持つ***ことに注意してください。つまり、ファームウェアはキーコードを最上位から最下位まで検索します。レイヤーで **`KC_TRNS`**(透過)以外のキーコードを見つけると、検索を中止し、下位レイヤーは参照されません。
+***上位のレイヤーはレイヤーのスタックでより高い優先順位を持つ***ことに注意してください。ファームウェアは最上位のアクティブレイヤーから下に向かってキーコードを検索します。ファームウェアがアクティブなレイヤーで `KC_TRNS` (透過)以外のキーコードを見つけると、検索を停止し、下位レイヤーは参照されません。

-オーバーレイレイヤーに `KC_TRANS`  を配置して、レイアウトの一部だけを変更して下位レイヤーまたは基本レイヤーにフォールバックすることができます。
-`KC_TRANS` (`KC_TRNS` と `_______` はエイリアス) のキーには独自のキーコードがなく、キーコードの有効な下位レイヤーを参照します。
+           ____________
+          /           /  <--- Higher layer
+         /  KC_TRNS  //
+        /___________//   <--- Lower layer (KC_A)
+        /___________/
+    
+    上記シナリオでは、上位レイヤーに非透過のキーが定義されているとそのキーが使われますが、`KC_TRNS` (または同等のキーコード)が定義されている場合は常に下位レベルのキーコード(`KC_A`)が使われます。
+
+**メモ:** 特定のレイヤーの透過性を示す有効な方法:
+* `KC_TRANSPARENT`
+* `KC_TRNS` (別名)
+* `_______` (別名)
+
+これらのキーコードは、処理する非透過のキーコードを探すときに、下位レイヤーを検索させることができます。

 ## `keymap.c` の分析

--- a/docs/ja/mod_tap.md
+++ b/docs/ja/mod_tap.md
@ -0,0 +1,59 @@
+# モッドタップ
+
+<!---
+  original document: 0.9.34:docs/mod_tap.md
+  git diff 0.9.34 HEAD -- docs/mod_tap.md | cat
+-->
+
+モッドタップキー `MT(mod, kc)` は、押したままの時にモディファイアのように機能し、タップされた時に通常のキーのように振舞います。別の言い方をすると、タップした時に Escape を送信しますが、押したままの時に Control あるいは Shift キーとして機能するキーを持つことができます。
+
+このキーコードと `OSM()` が受け付けるモディファイアは、`KC_` ではなく、`MOD_` の接頭辞が付いています:
+
+| モディファイア |  説明                                        |
+|----------------|----------------------------------------------|
+|  `MOD_LCTL`    | 左 Control                                   |
+|  `MOD_LSFT`    | 左 Shift                                     |
+|  `MOD_LALT`    | 左 Alt                                       |
+|  `MOD_LGUI`    | 左 GUI (Windows/Command/Meta キー)           |
+|  `MOD_RCTL`    | 右 Control                                   |
+|  `MOD_RSFT`    | 右 Shift                                     |
+|  `MOD_RALT`    | 右 Alt (AltGr)                               |
+|  `MOD_RGUI`    | 右 GUI (Windows/Command/Meta キー)           |
+|  `MOD_HYPR`    | Hyper (左 Control、左 Shift、左 Alt、左 GUI) |
+|  `MOD_MEH`     | Meh (左 Control、左 Shift、左 Alt)           |
+
+以下のようにそれらを OR することで、これらを組み合わせることができます:
+
+```c
+MT(MOD_LCTL | MOD_LSFT, KC_ESC)
+```
+
+押したままの時にこのキーは左 Control および左 Shift をアクティブにし、タップされた時に Escape を送信します。
+
+便利なように、QMK はキーマップで一般的な組み合わせをよりコンパクトにするためのモッドタップショートカットを含んでいます:
+
+| キー         | エイリアス                  | 説明                                                        |
+|--------------|-----------------------------|-------------------------------------------------------------|
+| `LCTL_T(kc)` | `CTL_T(kc)`                 | 押したままの場合は左 Control、タップした場合は `kc`         |
+| `LSFT_T(kc)` | `SFT_T(kc)`                 | 押したままの場合は左 Shift、タップした場合は `kc`           |
+| `LALT_T(kc)` | `LOPT_T(kc)`, `ALT_T(kc)`, `OPT_T(kc)`                            | 押したままの場合は左 Alt、タップした場合は `kc` |
+| `LGUI_T(kc)` | `LCMD_T(kc)`, `LWIN_T(kc)`, `GUI_T(kc)`, `CMD_T(kc)`, `WIN_T(kc)` | 押したままの場合は左 GUI、タップした場合は `kc` |
+| `RCTL_T(kc)` |                             | 押したままの場合は右 Control、タップした場合は `kc`         |
+| `RSFT_T(kc)` |                             | 押したままの場合は右 Shift、タップした場合は `kc`           |
+| `RALT_T(kc)` | `ROPT_T(kc)`, `ALGR_T(kc)`  | 押したままの場合は右 Alt、タップした場合は `kc`             |
+| `RGUI_T(kc)` | `RCMD_T(kc)`, `RWIN_T(kc)`  | 押したままの場合は右 GUI、タップした場合は `kc`             |
+| `SGUI_T(kc)` | `SCMD_T(kc)`, `SWIN_T(kc)`  | 押したままの場合は左 Shift と左 GUI、タップした場合は `kc`             |
+| `LCA_T(kc)`  |                             | 押したままの場合は左 Control と左 Alt、タップした場合は `kc`           |
+| `LCAG_T(kc)` |                             | 押したままの場合は左 Control、左 Alt と左 GUI、タップした場合は `kc`   |
+| `RCAG_T(kc)` |                             | 押したままの場合は右 Control、右 Alt と右 GUI、タップした場合は `kc`   |
+| `C_S_T(kc)`  |                             | 押したままの場合は左 Control と左 Shift、タップした場合は `kc`         |
+| `MEH_T(kc)`  |                             | 押したままの場合は左 Control、左 Shift と左 Alt、タップした場合は `kc` |
+| `HYPR_T(kc)` | `ALL_T(kc)`  | 押したままの場合は左 Control、左 Shift、左 Alt と左 GUI、タップした場合は `kc` - より詳しくは[ここ](http://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/)を見てください |
+
+## 注意事項
+
+残念ながら、キーコードで指定されたモディファイアは無視されるため、これらのキーコードはモッドタップまたはレイヤータップで使うことができません。
+
+さらに、Windows でリモートデスクトップ接続を使う場合に、問題が発生する場合があります。これらのコードはシフトを非常に高速に送信するため、リモートデスクトップはコードを見逃すかもしれません。
+
+これを修正するには、リモートデスクトップ接続を開き、「オプションの表示」を開き、「ローカル リソース」タブを開きます。キーボードセクションで、ドロップダウンを「このコンピューター」に変更します。これにより問題が修正され、キャラクタが正しく動作するようになります。
--- a/docs/ja/newbs_building_firmware.md
+++ b/docs/ja/newbs_building_firmware.md
@ -2,60 +2,41 @@

 <!---
  grep --no-filename "^[ ]*git diff" docs/ja/*.md | sh
-  original document: 0f43c2652:docs/newbs_building_firmware.md
-  git diff 0f43c2652 HEAD -- docs/newbs_building_firmware.md | cat
+  original document: 0.9.44:docs/newbs_building_firmware.md
+  git diff 0.9.44 HEAD -- docs/newbs_building_firmware.md | cat
 -->

 ビルド環境をセットアップしたので、カスタムファームウェアのビルドを開始する準備ができました。
 ガイドのこのセクションでは、ファイルマネージャ、テキストエディタ、ターミナルウィンドウの3つのプログラム間を行き来します。
 キーボードファームウェアが完成して満足するまで、この3つすべてを開いたままにします。

-ガイドの最初の部分を読んだ後でターミナルウィンドウを閉じて再度開いていた場合は、ターミナルが正しいディレクトリにあるように `cd qmk_firmware` を忘れないでください。
+## 新しいキーマップを作成する

-## キーマップフォルダに移動する
+独自のキーマップを作成するには、`default` キーマップのコピーを作成する必要があります。最後のステップでビルド環境を設定した場合は、QMK CLI を使って簡単に行うことができます:

-あなたのキーボードの `keymaps`フォルダに移動することから始めます。
+    qmk new-keymap

-macOS または Windows を使用している場合は、キーマップフォルダを簡単に開くために使用できるコマンドがあります。
+もし環境が設定されていない場合や、複数のキーボードを所持している場合は、キーボード名を指定することができます:

-### macOS:
+    qmk new-keymap -kb <keyboard_name>

-``` open keyboards/<keyboard_folder>/keymaps ```
+そのコマンドの出力を見ると、次のようになっているはずです:

-### Windows:
+    Ψ <github_username> keymap directory created in: /home/me/qmk_firmware/keyboards/clueboard/66/rev3/keymaps/<github_username>

-``` start .\\keyboards\\<keyboard_folder>\\keymaps ```
-
-## `default` キーマップのコピーを作成する
-
-`keymaps` フォルダを開いたら、`default`フォルダのコピーを作成します。
-フォルダには、あなたの GitHub でのユーザー名と同じ名前を付けることを強くお勧めしますが、小文字、数字、アンダースコアのみが含まれている限り、任意の名前を使用できます。
-
-この手順を自動化するために、`new_keymap.sh`スクリプトを実行する方法もあります。
-
-`qmk_firmware/util` ディレクトリに移動して、次を入力します。
-
-```
-./new_keymap.sh <keyboard path> <username>
-```
-
-たとえば、John という名前のユーザーが 1up60hse の新しいキーマップを作成しようとするには、次のように入力します。
-
-```
-./new_keymap.sh 1upkeyboards/1up60hse john
-```
+これがあなたの新しい `keymap.c` ファイルの場所です。

 ## あなたの好みのテキストエディタで `keymap.c` を開く

-`keymap.c`を開きます。
+テキストエディタで `keymap.c` ファイルを開きます。
 このファイル内には、キーボードの動作を制御する構造があります。
-`keymap.c`の上部には、キーマップを読みやすくする `define` と `enum` があります。
-さらに下には、次のような行があります。
+`keymap.c`の上部には、キーマップを読みやすくする定義と列挙型があります。
+さらに下には、次のような行があります:

    const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {

 この行はレイヤーのリストの開始を表わしています。
-その下には、`LAYOUT` または `KEYMAP` のいずれかを含む行があり、これらの行はレイヤーの開始を表わしています。
+その下には、`LAYOUT` を含む行があり、これらの行はレイヤーの開始を表わしています。
 その行の下には、そのレイヤーを構成するキーのリストがあります。

 !> キーマップファイルを編集するときは、カンマを追加したり削除したりしないように注意してください。そうするとファームウェアのコンパイルができなくなり、余分であったり欠落していたりするカンマがどこにあるのかを容易に把握できない場合があります。
@ -65,33 +46,34 @@ macOS または Windows を使用している場合は、キーマップフォ
 納得のいくまでこのステップを繰り返します。
 気になる点をひとつづつ変更して試すのもよし、全部作りなおすのもよし。
 あるレイヤー全体が必要ない場合はレイヤーを削除することもでき、必要があれば、合計 32 個までレイヤーを追加することもできます。
-ここで定義できる内容については、次のドキュメントを参照してください。
+QMK にはたくさんの機能があり、完全なリストは左側のサイドバーの「QMK を使う」の下を調べてください。ここから始めるために、簡単に使える機能をいくつか紹介します:

-* [キーコード](ja/keycodes.md)
-* [機能](ja/features.md)
-* [FAQ](ja/faq.md)
+* [基本的なキーコード](ja/keycodes_basic.md)
+* [Quantum キーコード](ja/quantum_keycodes.md)
+* [グレイブ エスケープ](ja/feature_grave_esc.md)
+* [マウスキー](ja/feature_mouse_keys.md)

 ?> キーマップがどのように機能するかを感じながら、各変更を小さくしてください。大きな変更は、発生する問題のデバッグを困難にします。

-## ファームウェアをビルドする
+## ファームウェアをビルドする :id=build-your-firmware

-キーマップの変更が完了したら、ファームウェアをビルドする必要があります。これを行うには、ターミナルウィンドウに戻り、ビルドコマンドを実行します:
+キーマップの変更が完了したら、ファームウェアをビルドする必要があります。これを行うには、ターミナルウィンドウに戻り、コンパイルコマンドを実行します:

-    make <my_keyboard>:<my_keymap>
+    qmk compile

-たとえば、キーマップの名前が "xyverz" で、rev5 planck のキーマップを作成している場合、次のコマンドを使用します:
+もし環境が設定されていない場合や、複数のキーボードを所持している場合は、キーボードやキーマップを指定することができます:

-    make planck/rev5:xyverz
+    qmk compile -kb <keyboard> -km <keymap>

 これがコンパイルされる間、どのファイルがコンパイルされているかを知らせる多くの出力が画面に表示されます。
-次のような出力で終わるはずです。
+次のような出力で終わるはずです:

 ```
-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
+Linking: .build/planck_rev5_default.elf                                                             [OK]
+Creating load file for flashing: .build/planck_rev5_default.hex                                     [OK]
+Copying planck_rev5_default.hex to qmk_firmware folder                                              [OK]
+Checking file size of planck_rev5_default.hex                                                       [OK]
+ * The firmware size is fine - 27312/28672 (95%, 1360 bytes free)
 ```

 ## ファームウェアを書きこむ
--- a/docs/ja/one_shot_keys.md
+++ b/docs/ja/one_shot_keys.md
@ -0,0 +1,107 @@
+# ワンショットキー
+
+<!---
+  original document: 0.9.34:docs/one_shot_keys.md
+  git diff 0.9.34 HEAD -- docs/one_shot_keys.md | cat
+-->
+
+ワンショットキーは次のキーが押されるまでアクティブのままになり、そのあと放されるキーです。これにより一度に1つ以上のキーを押すことなく、キーボードの組み合わせを入力することができます。これらのキーは通常「スティッキーキー」あるいは「デッドキー」と呼ばれます。
+
+例えば、キーを `OSM(MOD_LSFT)` と定義する場合、最初にシフトを押して放し、続いて A を押して放すことで、大文字の A キャラクタを入力することができます。コンピュータには、シフトが押された瞬間にシフトが押し続けられ、A が放された後ですぐにシフトキーが放されるように見えます。
+
+ワンショットキーは通常のモディファイアのようにも動作します。ワンショットキーを押しながら他のキーを入力すると、キーを放した直後にワンショットキーが解除されます。
+
+さらに、短時間でキーを5回押すと、そのキーをロックします。これはワンショットモディファイアとワンショットレイヤーに適用され、`ONESHOT_TAP_TOGGLE` 定義によって制御されます。
+
+`config.h` でこれらを定義することでワンショットキーの挙動を制御することができます:
+
+```c
+#define ONESHOT_TAP_TOGGLE 5  /* この回数をタップすると、もう一度タップするまでキーが押されたままになります。*/
+#define ONESHOT_TIMEOUT 5000  /* ワンショットキーが解除されるまでの時間 (ms) */
+```
+
+* `OSM(mod)` - *mod*を一時的に押し続けます。[モッドタップ](ja/mod_tap.md)で示したように、`KC_*` コードでは無く、`MOD_*` キーコードを使わなければなりません。
+* `OSL(layer)` - 一時的に*レイヤー*に切り替えます。
+
+ワンショットキーをマクロあるいはタップダンスルーチンの一部として有効にしたい場合があります。
+
+ワンショットレイヤーについては、キーを押した時に `set_oneshot_layer(LAYER, ONESHOT_START)` を呼び出し、キーを放した時に `clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED)` を呼び出す必要があります。ワンショットをキャンセルする場合は、`reset_oneshot_layer()` を呼び出してください。
+
+ワンショットモッドについては、設定するためには `set_oneshot_mods(MOD)` を呼び出し、キャンセルするためには `clear_oneshot_mods()` を呼び出す必要があります。
+
+!> リモートデスクトップ接続で OSM 変換に問題がある場合は、設定を開いて「ローカル リソース」タブに移動し、キーボードセクションでドロップダウンを「このコンピューター」に変更することで修正することができます。これにより問題が修正され、OSM がリモートデスクトップ上で適切に動作するようになります。
+
+## コールバック
+
+ワンショットキーを押す時にカスタムロジックを実行したい場合、実装を選択できる幾つかのコールバックがあります。例えば、LED を点滅させたり、音を鳴らしたりして、ワンショットキーの変化を示すことができます。
+
+`OSM(mod)` のためのコールバックがあります。ワンショット修飾キーの状態が変更されるたびに呼び出されます: オンに切り替わる時だけでなく、オフに切り替わる時にも呼び出されます。以下のように使うことができます:
+
+```c
+void oneshot_mods_changed_user(uint8_t mods) {
+  if (mods & MOD_MASK_SHIFT) {
+    println("Oneshot mods SHIFT");
+  }
+  if (mods & MOD_MASK_CTRL) {
+    println("Oneshot mods CTRL");
+  }
+  if (mods & MOD_MASK_ALT) {
+    println("Oneshot mods ALT");
+  }
+  if (mods & MOD_MASK_GUI) {
+    println("Oneshot mods GUI");
+  }
+  if (!mods) {
+    println("Oneshot mods off");
+  }
+}
+```
+
+`mods` 引数は変更後のアクティブな mod が含まれるため、現在の状態が反映されます。
+
+(`config.h` に `#define ONESHOT_TAP_TOGGLE 2` を追加して) ワンショットタップトグルを使う場合、指定された回数だけ修飾キーを押してロックすることができます。そのためのコールバックもあります:
+
+```c
+void oneshot_locked_mods_changed_user(uint8_t mods) {
+  if (mods & MOD_MASK_SHIFT) {
+    println("Oneshot locked mods SHIFT");
+  }
+  if (mods & MOD_MASK_CTRL) {
+    println("Oneshot locked mods CTRL");
+  }
+  if (mods & MOD_MASK_ALT) {
+    println("Oneshot locked mods ALT");
+  }
+  if (mods & MOD_MASK_GUI) {
+    println("Oneshot locked mods GUI");
+  }
+  if (!mods) {
+    println("Oneshot locked mods off");
+  }
+}
+```
+
+最後に、`OSL(layer)` ワンショットキーのためのコールバックもあります:
+
+```c
+void oneshot_layer_changed_user(uint8_t layer) {
+  if (layer == 1) {
+    println("Oneshot layer 1 on");
+  }
+  if (!layer) {
+    println("Oneshot layer off");
+  }
+}
+```
+
+いずれかのワンショットレイヤーがオフの場合、`layer` は 0 になります。ワンショットレイヤーの変更では無く、レイヤーの変更で何かを実行したい場合は、`layer_state_set_user` は使用するのに良いコールバックです。
+
+独自のキーボードを作成している場合、`_kb` と同等の機能もあります:
+
+```c
+void oneshot_locked_mods_changed_kb(uint8_t mods);
+void oneshot_mods_changed_kb(uint8_t mods);
+void oneshot_layer_changed_kb(uint8_t layer);
+```
+
+他のコールバックと同様に、更にカスタマイズを可能にするために `_user` バージョンを呼ぶようにしてください。
--- a/docs/ja/other_eclipse.md
+++ b/docs/ja/other_eclipse.md
@ -0,0 +1,93 @@
+# QMK 開発のための Eclipse セットアップ
+
+<!---
+  original document: 0.9.34:docs/other_eclipse.md
+  git diff 0.9.34 HEAD -- docs/other_eclipse.md | cat
+-->
+
+[Eclipse][1]は Java 開発のために広く使われているオープンソースの [統合開発環境](https://en.wikipedia.org/wiki/Integrated_development_environment) (IDE) ですが、他の言語および用途のためにカスタマイズできる拡張可能なプラグインシステムがあります。
+
+Eclipse のような IDE の使用は、プレーンテキストエディタの使用よりも多くの利点をもたらします。例えば、次のような利点です。
+* インテリジェントなコード補完
+* コード内の便利なナビゲーション
+* リファクタリングツール
+* 自動ビルド (コマンドラインは不要)
+* Git 用の GUI
+* 静的なコード解析
+* デバッグ、コードフォーマット、呼び出し階層の表示などの多くのツール。
+
+このページの目的は、AVR ソフトウェアの開発および QMK コードベースで作業するために、Eclipse をセットアップする方法を文章化することです。
+
+このセットアップは現時点では Ubuntu 16.04 でのみテストされていることに注意してください。
+
+# 前提条件
+## ビルド環境
+始める前に、チュートリアルの[セットアップ](ja/newbs_getting_started.md)のセクションに従う必要があります。特に、[`qmk compile` コマンド](ja/newbs_building_firmware.md#build-your-firmware)でファームウェアをビルドできなければなりません。
+
+## Java
+Eclipse は Java アプリケーションであるため、実行するには Java 8 以降をインストールする必要があります。JRE または JDK を選択できますが、Java 開発を行う場合は後者が役に立ちます。
+
+# Eclipse とプラグインのインストール
+Eclipse は用途に応じて[いくつかのフレーバー](http://www.eclipse.org/downloads/eclipse-packages/)で提供されます。AVR スタックを構成するパッケージは無いため、Eclipse CDT (C/C++ 開発ツール)から始め、必要なプラグインをインストールする必要があります。
+
+## Eclipse CDT のダウンロードとインストール
+システムに既に Eclipse CDT がある場合は、この手順をスキップできます。ただし、より良いサポートのために最新の状態に保つことをお勧めします。
+
+別の Eclipse パッケージをインストールしている場合は、通常は[その上に CDT プラグインをインストール](https://eclipse.org/cdt/downloads.php)することができます。しかし、軽くして、作業中のプロジェクトに必要のないツールが乱雑にならないように、ゼロから再インストールすることをお勧めします。
+
+インストールは非常に簡単です: [5 Steps to install Eclipse](https://eclipse.org/downloads/eclipse-packages/?show_instructions=TRUE) に従い、ステップ3で **Eclipse IDE for C/C++ Developers** を選択します。
+
+あるいは、直接 [Eclipse IDE for C/C++ Developers をダウンロード](http://www.eclipse.org/downloads/eclipse-packages/)([現在のバージョンへの直接リンク](http://www.eclipse.org/downloads/packages/eclipse-ide-cc-developers/neonr))し、選択した場所にパッケージを解凍することもできます (これにより `eclipse` フォルダが作成されます)。
+
+## 最初の起動
+インストールが完了したら、<kbd>Launch</kbd> ボタンをクリックします。(パッケージを手動で解凍した場合は、Eclipse をインストールしたフォルダを開き、`eclipse` 実行可能ファイルをダブルクリックします)
+
+Workspace 選択で入力を促された場合は、Eclipse メタデータと通常のプロジェクトを保持するディレクトリを選択します。**`qmk_firmware` ディレクトリを選択しないでください**。これはプロジェクトディレクトリになります。代わりに親フォルダを選択するか、(できれば空の)他のフォルダを選択します(まだ使用していない場合は、デフォルトで問題ありません)。
+
+開始したら、右上の <kbd>Workbench</kbd> ボタンをクリックし、workbench ビューに切り替えます (下部に開始時のようこそ画面をスキップするためのチェックボックスもあります)。
+
+## 必要なプラグインをインストール
+注意: プラグインをインストールするごとに、Eclipse を再起動する必要はありません。全てのプラグインがインストールされたら単に1回再起動します。
+
+### [The AVR Plugin](http://avr-eclipse.sourceforge.net/)
+これは最も重要なプラグインで、Eclipse が AVR C コードを_理解_できるようになります。[更新サイトを使うための指示](http://avr-eclipse.sourceforge.net/wiki/index.php/Plugin_Download#Update_Site)に従い、未署名コンテンツのセキュリティ警告に同意します。
+
+### [ANSI Escape in Console](https://marketplace.eclipse.org/content/ansi-escape-console)
+このプラグインは QMK makefile によって生成された色付きビルド出力を適切に表示するために必要です。
+
+1. <kbd><kbd>Help</kbd> > <kbd>Eclipse Marketplace…</kbd></kbd> を開きます
+2. _ANSI Escape in Console_ を検索します
+3. プラグインの <samp>Install</samp> ボタンをクリックします
+4. 指示に従い、未署名コンテンツのセキュリティ警告に再度同意します。
+
+両方のプラグインがインストールされたら、プロンプトに従って Eclipse を再起動します。
+
+# QMK 用の Eclipse の設定
+## プロジェクトのインポート
+1. <kbd><kbd>File</kbd> > <kbd>New</kbd> > <kbd>Makefile Project with Existing Code</kbd></kbd> をクリックします
+2. 次の画面で:
+* _Existing Code Location_ としてリポジトリをクローンしたディレクトリを選択します。
+* (オプション) プロジェクトに別の名前を付けます¹ 例えば _QMK_ あるいは _Quantum_;
+* _AVR-GCC Toolchain_ を選択します;
+* 残りをそのままにして、<kbd>Finish</kbd> をクリックします
+
+![Eclipse での QMK のインポート](http://i.imgur.com/oHYR1yW.png)
+
+3. これでプロジェクトがロードされインデックスされます。左側の _Project Explorer_ から、簡単にファイルを参照できます。
+
+¹ カスタム名でプロジェクトをインポートすると問題が発生するかもしれません。正しく動作しない場合は、デフォルトのプロジェクト名 (つまり、ディレクトリの名前、おそらく `qmk_firmware`) のままにしてみてください。
+
+## キーボードのビルド
+ここで、プロジェクトをクリーンし、選択したキーマップをビルドする make target を設定します。
+
+1. 画面の右側で、<kbd>Make Target</kbd> タブを選択します
+2. フォルダツリーを選択したキーボードまで展開します。例えば、`qmk_firmware/keyboards/ergodox`
+3. キーボードフォルダを右クリックして、<kbd>New…</kbd> を選択します (あるいはフォルダを選択し、ツリーの上にある <kbd>New Make Target</kbd> アイコンをクリックします)
+4. ビルド target の名前を選択します。例えば、_clean \<your keymap\>_
+5. Make Target: これはコマンドラインからビルドする時に `make` に渡す引数です。target 名がこれらの引数と一致しない場合は、<kbd>Same as target name</kbd> のチェックを外し、正しい引数を入力します。例えば、`clean <your keymap>`
+6. 他のオプションはチェックしたままにして、<kbd>OK</kbd> をクリックします。これで、選択されたキーボードの下に、make target が表示されます。
+7. (オプション) target ツリーの上にある <kbd>Hide Empty Folders</kbd> アイコンボタンを、ビルド target だけが表示されるように切り替えます。
+8. 作成したビルド target をダブルクリックし、ビルドを起動します。
+9. 下部の <kbd>Console</kbd> ビューを選択し、実行中のビルドを眺めます。
+
+[1]: https://en.wikipedia.org/wiki/Eclipse_(software)
--- a/docs/ja/other_vscode.md
+++ b/docs/ja/other_vscode.md
@ -0,0 +1,122 @@
+# QMK 開発用の Visual Studio Code のセットアップ
+
+<!---
+  original document: 0.9.34:docs/other_vscode.md
+  git diff 0.9.34 HEAD -- docs/other_vscode.md | cat
+-->
+
+[Visual Studio Code](https://code.visualstudio.com/) (VS Code) は多くの異なるプログラミング言語をサポートするオープンソースのコードエディタです。
+
+VS Code のようなフル機能のエディタの使用は、プレーンテキストエディタの使用よりも多くの利点をもたらします。例えば、次のような利点です。:
+* インテリジェントなコード補完
+* コード内の便利なナビゲーション
+* リファクタリングツール
+* 自動ビルド (コマンドラインは不要)
+* Git 用のグラフィカルなフロントエンド
+* デバッグ、コードフォーマット、呼び出し階層の表示などの多くのツール
+
+このページの目的は、QMK ファームウェアを開発するために VS Code をセットアップする方法を文章化することです。
+
+このガイドは Windows および Ubuntu 18.04 で必要な全てを構成する方法を説明します。
+
+# VS Code のセットアップ
+はじめに、全てのビルドツールをセットアップし、QMK ファームウェアをクローンする必要があります。まだ設定していない場合は、[セットアップ](ja/newbs_getting_started.md)に進んでください。
+
+## Windows
+
+### 前提条件
+
+* [Git for Windows](https://git-scm.com/download/win) (このリンクはインストーラを保存あるいは実行するように促します)
+
+   1. `Git LFS (Large File Support)` および `Check daily for Git for Windows updates` 以外の全てのオプションを無効にします。
+   2. デフォルトのエディタを `Use Visual Studio Code as Git's default editor` に設定します。
+   3. ここで使用すべきオプションなので、`Use Git from Git Bash only` オプションを選択します。
+   4. `Choosing HTTPS transport backend` については、どちらのオプションでも問題ありません。
+   5. `Checkout as-is, commit Unix-style line endings` オプションを選択します。QMK ファームウェアは Unix スタイルのコミットを使います。
+   6. 追加のオプションについては、デフォルトのオプションをそのままにします。
+
+  このソフトウェアは、VS Code での Git サポートに必要です。これを含めないことも可能ですが、これを使う方が簡単です。
+
+* [Git Credential Manager for Windows](https://github.com/Microsoft/Git-Credential-Manager-for-Windows/releases) (オプション)
+
+   このソフトウェアは、git 証明書、MFA、パーソナルアクセストークン生成のためのセキュアストレージを提供することで、Git のより良いサポートを提供します。
+
+   これは厳密には必要ありませんが、お勧めします。
+
+
+### VS Code のインストール
+
+1. [VS Code](https://code.visualstudio.com/) に進み、インストーラをダウンロードします
+2. インストーラを実行します
+
+この項は非常に簡単です。ただし、正しく構成されていることを確認するために、しなければならない幾つかの設定があります。
+
+### VS Code の設定
+
+最初に、IntelliSense をセットアップする必要があります。これは厳密には必要ではありませんが、あなたの人生をずっと楽にします。これを行うには、QMK ファームウェアフォルダに `.vscode/c_cpp_properies.json` ファイルを作成する必要があります。これは全て手動で行うことができますが、ほとんどの作業は既に完了しています。
+
+[このファイル](https://gist.github.com/drashna/48e2c49ce877be592a1650f91f8473e8) を取得して保存します。MSYS2 をデフォルトの場所にインストールしなかった、または WSL か LxSS を使っている場合、このファイルを編集する必要があります。
+
+このファイルを保存したら、VS Code が既に実行中の場合はリロードする必要があります。
+
+?> また、`.vscode` フォルダ に `extensions.json` および `settings.json` ファイルがあるはずです。
+
+
+次に、VSCode に統合ターミナルとして表示されるように、MSYS2 ウィンドウを設定します。これには多くの利点があります。ほとんどの場合で、エラー上で Ctrl + クリックするとこれらのファイルにジャンプできます。これによりデバッグがはるかに簡単になります。また、他のウィンドウへジャンプする必要が無いという点でも優れています。
+
+1. <kbd><kbd>File</kbd> > <kbd>Preferences ></kbd> > <kbd>Settings</kbd> </kbd> をクリックします。
+2. 右上の <kbd>{}</kbd> ボタンをクリックし、`settings.json` ファイルを開きます。
+3. ファイルの内容を以下のように設定します:
+
+   ```json
+   {
+        "terminal.integrated.shell.windows": "C:\\msys64\\usr\\bin\\bash.exe",
+        "terminal.integrated.env.windows": {
+            "MSYSTEM": "MINGW64",
+            "CHERE_INVOKING": "1"
+        },
+        "terminal.integrated.shellArgs.windows": [
+            "--login"
+        ],
+        "terminal.integrated.cursorStyle": "line"
+    }
+    ```
+
+   ここに既に設定がある場合は、最初と最後の波括弧の間に全てを追加します。
+
+?> MSYS2 を別のフォルダにインストールした場合は、`terminal.integrated.shell.windows` のパスをシステムの正しいパスに変更する必要があります。
+
+4. Ctrl-` (grave) を押して、ターミナルを起動します。
+
+   これにより、ワークスペースフォルダ(つまり `qmk_firmware` フォルダ)でターミナルが起動し、キーボードをコンパイルすることができます。
+
+
+## 他の全てのオペレーティングシステム
+
+1. [VS Code](https://code.visualstudio.com/) に進み、インストーラをダウンロードします
+2. インストーラを実行します
+3. 以上です
+
+いいえ、本当に以上です。必要なパスはパッケージのインストール時に既に含まれています。現在のワークスペースのファイルを検出し、IntelliSense 用に解析する方がより良いです。
+
+## プラグイン
+
+インストールした方が良い拡張が幾つかあります。
+
+* [Git Extension Pack](https://marketplace.visualstudio.com/items?itemName=donjayamanne.git-extension-pack) -
+これは QMK ファームウェアで Git を簡単に使用できる Git 関連ツールを多数インスールします。
+* [EditorConfig for VS Code](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) - _[オプション]_ -  QMK コーディング規約にコードを準拠させるのに役立ちます。
+* [Bracket Pair Colorizer 2](https://marketplace.visualstudio.com/items?itemName=CoenraadS.bracket-pair-colorizer-2) - _[オプション]_ - これはネストされたコードを参照しやすくするために、コード内の括弧を色分けします。
+* [GitHub Markdown Preview](https://marketplace.visualstudio.com/items?itemName=bierner.github-markdown-preview) - _[オプション]_ - VS Code の markdown プレビューを GithHub のようにします。
+* [VS Live Share Extension Pack](https://marketplace.visualstudio.com/items?itemName=MS-vsliveshare.vsliveshare-pack) - _[オプション]_ - この拡張により、他の誰かがあなたのワークスペースにアクセスし(あるいは、あなたが他の誰かのワークスペースにアクセスし)、手伝うことができます。あなたが問題を抱えており、他の誰かの助けが必要な場合に便利です。
+* [VIM Keymap](https://marketplace.visualstudio.com/items?itemName=GiuseppeCesarano.vim-keymap) - _[オプション]_ - VIM スタイルのキーバインドを好む人向け。これには他のオプションもあります。
+* [Travis CI Status](https://marketplace.visualstudio.com/items?itemName=felixrieseberg.vsc-travis-ci-status) - _[オプション]_ - セットアップした場合、現在の Travis CI の状態を表示します。
+
+いずれかの拡張機能をインストールしたら、再起動します。
+
+# QMK 用の VS Code の設定
+1. <kbd><kbd>File</kbd> > <kbd>Open Folder</kbd></kbd> をクリックします
+2. GitHub からクローンした QMK ファームウェアフォルダを開きます。
+3. <kbd><kbd>File</kbd> > <kbd>Save Workspace As...</kbd></kbd> をクリックします
+
+これで、VS Code で QMK ファームウェアをコーディングする準備ができました。
--- a/docs/ref_functions.md
+++ b/docs/ref_functions.md
@ -26,7 +26,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
        update_tri_layer(_LOWER, _RAISE, _ADJUST);
      }
      return false;
-      break;
    case RAISE:
      if (record->event.pressed) {
        layer_on(_RAISE);
@ -36,7 +35,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
        update_tri_layer(_LOWER, _RAISE, _ADJUST);
      }
      return false;
-      break;
    }
  return true;
 }
--- a/docs/zh-cn/custom_quantum_functions.md
+++ b/docs/zh-cn/custom_quantum_functions.md
@ -424,7 +424,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
                layer_state_set(layer_state);   // 那么立刻更新层颜色
            }
        }
-        return false; break;
+        return false;
    case RGB_MODE_FORWARD ... RGB_MODE_GRADIENT: // 对于所有的RGB代码 (see quantum_keycodes.h, L400 可以参考)
        if (record->event.pressed) { //本句失能层指示，假设你改变了这个…你要把它禁用
            if (user_config.rgb_layer_change) {        // 仅当使能时
--- a/drivers/chibios/i2c_master.c
+++ b/drivers/chibios/i2c_master.c
@ -32,7 +32,9 @@
 static uint8_t i2c_address;

 static const I2CConfig i2cconfig = {
-#ifdef USE_I2CV1
+#if defined(USE_I2CV1_CONTRIB)
+    I2C1_CLOCK_SPEED,
+#elif defined(USE_I2CV1)
    I2C1_OPMODE,
    I2C1_CLOCK_SPEED,
    I2C1_DUTY_CYCLE,
@ -62,8 +64,8 @@ __attribute__((weak)) void i2c_init(void) {

    chThdSleepMilliseconds(10);
 #if defined(USE_GPIOV1)
-    palSetPadMode(I2C1_SCL_BANK, I2C1_SCL, PAL_MODE_STM32_ALTERNATE_OPENDRAIN);
-    palSetPadMode(I2C1_SDA_BANK, I2C1_SDA, PAL_MODE_STM32_ALTERNATE_OPENDRAIN);
+    palSetPadMode(I2C1_SCL_BANK, I2C1_SCL, I2C1_SCL_PAL_MODE);
+    palSetPadMode(I2C1_SDA_BANK, I2C1_SDA, I2C1_SDA_PAL_MODE);
 #else
    palSetPadMode(I2C1_SCL_BANK, I2C1_SCL, PAL_MODE_ALTERNATE(I2C1_SCL_PAL_MODE) | PAL_STM32_OTYPE_OPENDRAIN);
    palSetPadMode(I2C1_SDA_BANK, I2C1_SDA, PAL_MODE_ALTERNATE(I2C1_SDA_PAL_MODE) | PAL_STM32_OTYPE_OPENDRAIN);
--- a/drivers/chibios/i2c_master.h
+++ b/drivers/chibios/i2c_master.h
@ -81,7 +81,14 @@
 #    define I2C_DRIVER I2CD1
 #endif

-#ifndef USE_GPIOV1
+#ifdef USE_GPIOV1
+#    ifndef I2C1_SCL_PAL_MODE
+#        define I2C1_SCL_PAL_MODE PAL_MODE_STM32_ALTERNATE_OPENDRAIN
+#    endif
+#    ifndef I2C1_SDA_PAL_MODE
+#        define I2C1_SDA_PAL_MODE PAL_MODE_STM32_ALTERNATE_OPENDRAIN
+#    endif
+#else
 // The default PAL alternate modes are used to signal that the pins are used for I2C
 #    ifndef I2C1_SCL_PAL_MODE
 #        define I2C1_SCL_PAL_MODE 4
--- a/drivers/oled/oled_driver.c
+++ b/drivers/oled/oled_driver.c
@ -82,14 +82,12 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define I2C_CMD 0x00
 #define I2C_DATA 0x40
 #if defined(__AVR__)
-// already defined on ARM
-#    define I2C_TIMEOUT 100
-#    define I2C_TRANSMIT_P(data) i2c_transmit_P((OLED_DISPLAY_ADDRESS << 1), &data[0], sizeof(data), I2C_TIMEOUT)
+#    define I2C_TRANSMIT_P(data) i2c_transmit_P((OLED_DISPLAY_ADDRESS << 1), &data[0], sizeof(data), OLED_I2C_TIMEOUT)
 #else  // defined(__AVR__)
-#    define I2C_TRANSMIT_P(data) i2c_transmit((OLED_DISPLAY_ADDRESS << 1), &data[0], sizeof(data), I2C_TIMEOUT)
+#    define I2C_TRANSMIT_P(data) i2c_transmit((OLED_DISPLAY_ADDRESS << 1), &data[0], sizeof(data), OLED_I2C_TIMEOUT)
 #endif  // defined(__AVR__)
-#define I2C_TRANSMIT(data) i2c_transmit((OLED_DISPLAY_ADDRESS << 1), &data[0], sizeof(data), I2C_TIMEOUT)
-#define I2C_WRITE_REG(mode, data, size) i2c_writeReg((OLED_DISPLAY_ADDRESS << 1), mode, data, size, I2C_TIMEOUT)
+#define I2C_TRANSMIT(data) i2c_transmit((OLED_DISPLAY_ADDRESS << 1), &data[0], sizeof(data), OLED_I2C_TIMEOUT)
+#define I2C_WRITE_REG(mode, data, size) i2c_writeReg((OLED_DISPLAY_ADDRESS << 1), mode, data, size, OLED_I2C_TIMEOUT)

 #define HAS_FLAGS(bits, flags) ((bits & flags) == flags)

@ -462,6 +460,19 @@ void oled_write_raw(const char *data, uint16_t size) {
    }
 }

+void oled_write_pixel(uint8_t x, uint8_t y, bool on) {
+    if (x >= OLED_DISPLAY_WIDTH || y >= OLED_DISPLAY_HEIGHT) {
+        return;
+    }
+    uint16_t index = x + (y / 8) * OLED_DISPLAY_WIDTH;
+    if (on) {
+        oled_buffer[index] |= (1 << (y % 8));
+    } else {
+        oled_buffer[index] &= ~(1 << (y % 8));
+    }
+    oled_dirty |= (1 << (index / OLED_BLOCK_SIZE));
+}
+
 #if defined(__AVR__)
 void oled_write_P(const char *data, bool invert) {
    uint8_t c = pgm_read_byte(data);
--- a/drivers/oled/oled_driver.h
+++ b/drivers/oled/oled_driver.h
@ -150,6 +150,10 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #    endif
 #endif

+#if !defined(OLED_I2C_TIMEOUT)
+#    define OLED_I2C_TIMEOUT 100
+#endif
+
 // OLED Rotation enum values are flags
 typedef enum {
    OLED_ROTATION_0   = 0,
@ -206,6 +210,10 @@ void oled_pan(bool left);
 void oled_write_raw(const char *data, uint16_t size);
 void oled_write_raw_byte(const char data, uint16_t index);

+// Sets a specific pixel on or off
+// Coordinates start at top-left and go right and down for positive x and y
+void oled_write_pixel(uint8_t x, uint8_t y, bool on);
+
 #if defined(__AVR__)
 // Writes a PROGMEM string to the buffer at current cursor position
 // Advances the cursor while writing, inverts the pixels if true
--- a/keyboards/1upkeyboards/1up60hse/config.h
+++ b/keyboards/1upkeyboards/1up60hse/config.h
@ -189,31 +189,3 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.

 /* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
 //#define MIDI_TONE_KEYCODE_OCTAVES 1
-
-/*
- * HD44780 LCD Display Configuration
- */
-/*
-#define LCD_LINES           2     //< number of visible lines of the display
-#define LCD_DISP_LENGTH    16     //< visibles characters per line of the display
-
-#define LCD_IO_MODE      1            //< 0: memory mapped mode, 1: IO port mode
-
-#if LCD_IO_MODE
-#define LCD_PORT         PORTB        //< port for the LCD lines
-#define LCD_DATA0_PORT   LCD_PORT     //< port for 4bit data bit 0
-#define LCD_DATA1_PORT   LCD_PORT     //< port for 4bit data bit 1
-#define LCD_DATA2_PORT   LCD_PORT     //< port for 4bit data bit 2
-#define LCD_DATA3_PORT   LCD_PORT     //< port for 4bit data bit 3
-#define LCD_DATA0_PIN    4            //< pin for 4bit data bit 0
-#define LCD_DATA1_PIN    5            //< pin for 4bit data bit 1
-#define LCD_DATA2_PIN    6            //< pin for 4bit data bit 2
-#define LCD_DATA3_PIN    7            //< pin for 4bit data bit 3
-#define LCD_RS_PORT      LCD_PORT     //< port for RS line
-#define LCD_RS_PIN       3            //< pin  for RS line
-#define LCD_RW_PORT      LCD_PORT     //< port for RW line
-#define LCD_RW_PIN       2            //< pin  for RW line
-#define LCD_E_PORT       LCD_PORT     //< port for Enable line
-#define LCD_E_PIN        1            //< pin  for Enable line
-#endif
-*/
--- a/keyboards/1upkeyboards/1up60hse/rules.mk
+++ b/keyboards/1upkeyboards/1up60hse/rules.mk
@ -30,7 +30,6 @@ UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
-HD44780_ENABLE = no 		# Enable support for HD44780 based LCDs
 EXTRAFLAGS += -flto

 LAYOUTS = 60_ansi
--- a/keyboards/1upkeyboards/super16/config.h
+++ b/keyboards/1upkeyboards/super16/config.h
@ -219,34 +219,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
 //#define MIDI_TONE_KEYCODE_OCTAVES 1

-/*
- * HD44780 LCD Display Configuration
- */
-/*
-#define LCD_LINES           2     //< number of visible lines of the display
-#define LCD_DISP_LENGTH    16     //< visibles characters per line of the display
-
-#define LCD_IO_MODE      1            //< 0: memory mapped mode, 1: IO port mode
-
-#if LCD_IO_MODE
-#define LCD_PORT         PORTB        //< port for the LCD lines
-#define LCD_DATA0_PORT   LCD_PORT     //< port for 4bit data bit 0
-#define LCD_DATA1_PORT   LCD_PORT     //< port for 4bit data bit 1
-#define LCD_DATA2_PORT   LCD_PORT     //< port for 4bit data bit 2
-#define LCD_DATA3_PORT   LCD_PORT     //< port for 4bit data bit 3
-#define LCD_DATA0_PIN    4            //< pin for 4bit data bit 0
-#define LCD_DATA1_PIN    5            //< pin for 4bit data bit 1
-#define LCD_DATA2_PIN    6            //< pin for 4bit data bit 2
-#define LCD_DATA3_PIN    7            //< pin for 4bit data bit 3
-#define LCD_RS_PORT      LCD_PORT     //< port for RS line
-#define LCD_RS_PIN       3            //< pin  for RS line
-#define LCD_RW_PORT      LCD_PORT     //< port for RW line
-#define LCD_RW_PIN       2            //< pin  for RW line
-#define LCD_E_PORT       LCD_PORT     //< port for Enable line
-#define LCD_E_PIN        1            //< pin  for Enable line
-#endif
-*/
-
 /* Bootmagic Lite key configuration */
 // #define BOOTMAGIC_LITE_ROW 0
 // #define BOOTMAGIC_LITE_COLUMN 0
--- a/keyboards/1upkeyboards/super16/rules.mk
+++ b/keyboards/1upkeyboards/super16/rules.mk
@ -31,6 +31,5 @@ UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
-HD44780_ENABLE = no         # Enable support for HD44780 based LCDs

 LAYOUTS = ortho_4x4 numpad_4x4
--- a/keyboards/40percentclub/25/config.h
+++ b/keyboards/40percentclub/25/config.h
@ -197,31 +197,3 @@

 /* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
 //#define MIDI_TONE_KEYCODE_OCTAVES 1
-
-/*
- * HD44780 LCD Display Configuration
- */
-/*
-#define LCD_LINES           2     //< number of visible lines of the display
-#define LCD_DISP_LENGTH    16     //< visibles characters per line of the display
-
-#define LCD_IO_MODE      1            //< 0: memory mapped mode, 1: IO port mode
-
-#if LCD_IO_MODE
-#define LCD_PORT         PORTB        //< port for the LCD lines
-#define LCD_DATA0_PORT   LCD_PORT     //< port for 4bit data bit 0
-#define LCD_DATA1_PORT   LCD_PORT     //< port for 4bit data bit 1
-#define LCD_DATA2_PORT   LCD_PORT     //< port for 4bit data bit 2
-#define LCD_DATA3_PORT   LCD_PORT     //< port for 4bit data bit 3
-#define LCD_DATA0_PIN    4            //< pin for 4bit data bit 0
-#define LCD_DATA1_PIN    5            //< pin for 4bit data bit 1
-#define LCD_DATA2_PIN    6            //< pin for 4bit data bit 2
-#define LCD_DATA3_PIN    7            //< pin for 4bit data bit 3
-#define LCD_RS_PORT      LCD_PORT     //< port for RS line
-#define LCD_RS_PIN       3            //< pin  for RS line
-#define LCD_RW_PORT      LCD_PORT     //< port for RW line
-#define LCD_RW_PIN       2            //< pin  for RW line
-#define LCD_E_PORT       LCD_PORT     //< port for Enable line
-#define LCD_E_PIN        1            //< pin  for Enable line
-#endif
-*/
--- a/keyboards/40percentclub/25/rules.mk
+++ b/keyboards/40percentclub/25/rules.mk
@ -30,7 +30,6 @@ UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
-HD44780_ENABLE = no 		    # Enable support for HD44780 based LCDs

 # Enable generic behavior for split boards
 SPLIT_KEYBOARD = yes
--- a/keyboards/40percentclub/4pack/config.h
+++ b/keyboards/40percentclub/4pack/config.h
@ -224,34 +224,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
 //#define MIDI_TONE_KEYCODE_OCTAVES 1

-/*
- * HD44780 LCD Display Configuration
- */
-/*
-#define LCD_LINES           2     //< number of visible lines of the display
-#define LCD_DISP_LENGTH    16     //< visibles characters per line of the display
-
-#define LCD_IO_MODE      1            //< 0: memory mapped mode, 1: IO port mode
-
-#if LCD_IO_MODE
-#define LCD_PORT         PORTB        //< port for the LCD lines
-#define LCD_DATA0_PORT   LCD_PORT     //< port for 4bit data bit 0
-#define LCD_DATA1_PORT   LCD_PORT     //< port for 4bit data bit 1
-#define LCD_DATA2_PORT   LCD_PORT     //< port for 4bit data bit 2
-#define LCD_DATA3_PORT   LCD_PORT     //< port for 4bit data bit 3
-#define LCD_DATA0_PIN    4            //< pin for 4bit data bit 0
-#define LCD_DATA1_PIN    5            //< pin for 4bit data bit 1
-#define LCD_DATA2_PIN    6            //< pin for 4bit data bit 2
-#define LCD_DATA3_PIN    7            //< pin for 4bit data bit 3
-#define LCD_RS_PORT      LCD_PORT     //< port for RS line
-#define LCD_RS_PIN       3            //< pin  for RS line
-#define LCD_RW_PORT      LCD_PORT     //< port for RW line
-#define LCD_RW_PIN       2            //< pin  for RW line
-#define LCD_E_PORT       LCD_PORT     //< port for Enable line
-#define LCD_E_PIN        1            //< pin  for Enable line
-#endif
-*/
-
 /* Bootmagic Lite key configuration */
 // #define BOOTMAGIC_LITE_ROW 0
 // #define BOOTMAGIC_LITE_COLUMN 0
--- a/keyboards/40percentclub/4pack/rules.mk
+++ b/keyboards/40percentclub/4pack/rules.mk
@ -30,4 +30,3 @@ UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
-HD44780_ENABLE = no         # Enable support for HD44780 based LCDs
--- a/keyboards/40percentclub/4x4/config.h
+++ b/keyboards/40percentclub/4x4/config.h
@ -164,31 +164,3 @@

 /* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
 //#define MIDI_TONE_KEYCODE_OCTAVES 1
-
-/*
- * HD44780 LCD Display Configuration
- */
-/*
-#define LCD_LINES           2     //< number of visible lines of the display
-#define LCD_DISP_LENGTH    16     //< visibles characters per line of the display
-
-#define LCD_IO_MODE      1            //< 0: memory mapped mode, 1: IO port mode
-
-#if LCD_IO_MODE
-#define LCD_PORT         PORTB        //< port for the LCD lines
-#define LCD_DATA0_PORT   LCD_PORT     //< port for 4bit data bit 0
-#define LCD_DATA1_PORT   LCD_PORT     //< port for 4bit data bit 1
-#define LCD_DATA2_PORT   LCD_PORT     //< port for 4bit data bit 2
-#define LCD_DATA3_PORT   LCD_PORT     //< port for 4bit data bit 3
-#define LCD_DATA0_PIN    4            //< pin for 4bit data bit 0
-#define LCD_DATA1_PIN    5            //< pin for 4bit data bit 1
-#define LCD_DATA2_PIN    6            //< pin for 4bit data bit 2
-#define LCD_DATA3_PIN    7            //< pin for 4bit data bit 3
-#define LCD_RS_PORT      LCD_PORT     //< port for RS line
-#define LCD_RS_PIN       3            //< pin  for RS line
-#define LCD_RW_PORT      LCD_PORT     //< port for RW line
-#define LCD_RW_PIN       2            //< pin  for RW line
-#define LCD_E_PORT       LCD_PORT     //< port for Enable line
-#define LCD_E_PIN        1            //< pin  for Enable line
-#endif
-*/
--- a/keyboards/40percentclub/4x4/rules.mk
+++ b/keyboards/40percentclub/4x4/rules.mk
@ -29,6 +29,5 @@ UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
-HD44780_ENABLE = no 				# Enable support for HD44780 based LCDs

 LAYOUTS = ortho_4x4  ortho_4x8  ortho_4x12  ortho_4x16
--- a/keyboards/40percentclub/5x5/config.h
+++ b/keyboards/40percentclub/5x5/config.h
@ -173,31 +173,3 @@

 /* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
 //#define MIDI_TONE_KEYCODE_OCTAVES 1
-
-/*
- * HD44780 LCD Display Configuration
- */
-/*
-#define LCD_LINES           2     //< number of visible lines of the display
-#define LCD_DISP_LENGTH    16     //< visibles characters per line of the display
-
-#define LCD_IO_MODE      1            //< 0: memory mapped mode, 1: IO port mode
-
-#if LCD_IO_MODE
-#define LCD_PORT         PORTB        //< port for the LCD lines
-#define LCD_DATA0_PORT   LCD_PORT     //< port for 4bit data bit 0
-#define LCD_DATA1_PORT   LCD_PORT     //< port for 4bit data bit 1
-#define LCD_DATA2_PORT   LCD_PORT     //< port for 4bit data bit 2
-#define LCD_DATA3_PORT   LCD_PORT     //< port for 4bit data bit 3
-#define LCD_DATA0_PIN    4            //< pin for 4bit data bit 0
-#define LCD_DATA1_PIN    5            //< pin for 4bit data bit 1
-#define LCD_DATA2_PIN    6            //< pin for 4bit data bit 2
-#define LCD_DATA3_PIN    7            //< pin for 4bit data bit 3
-#define LCD_RS_PORT      LCD_PORT     //< port for RS line
-#define LCD_RS_PIN       3            //< pin  for RS line
-#define LCD_RW_PORT      LCD_PORT     //< port for RW line
-#define LCD_RW_PIN       2            //< pin  for RW line
-#define LCD_E_PORT       LCD_PORT     //< port for Enable line
-#define LCD_E_PIN        1            //< pin  for Enable line
-#endif
-*/
--- a/keyboards/40percentclub/5x5/rules.mk
+++ b/keyboards/40percentclub/5x5/rules.mk
@ -29,6 +29,5 @@ UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
-HD44780_ENABLE = no 				# Enable support for HD44780 based LCDs

 LAYOUTS = ortho_5x5  ortho_5x10  ortho_5x15
--- a/keyboards/40percentclub/6lit/config.h
+++ b/keyboards/40percentclub/6lit/config.h
@ -198,31 +198,3 @@

 /* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
 //#define MIDI_TONE_KEYCODE_OCTAVES 1
-
-/*
- * HD44780 LCD Display Configuration
- */
-/*
-#define LCD_LINES           2     //< number of visible lines of the display
-#define LCD_DISP_LENGTH    16     //< visibles characters per line of the display
-
-#define LCD_IO_MODE      1            //< 0: memory mapped mode, 1: IO port mode
-
-#if LCD_IO_MODE
-#define LCD_PORT         PORTB        //< port for the LCD lines
-#define LCD_DATA0_PORT   LCD_PORT     //< port for 4bit data bit 0
-#define LCD_DATA1_PORT   LCD_PORT     //< port for 4bit data bit 1
-#define LCD_DATA2_PORT   LCD_PORT     //< port for 4bit data bit 2
-#define LCD_DATA3_PORT   LCD_PORT     //< port for 4bit data bit 3
-#define LCD_DATA0_PIN    4            //< pin for 4bit data bit 0
-#define LCD_DATA1_PIN    5            //< pin for 4bit data bit 1
-#define LCD_DATA2_PIN    6            //< pin for 4bit data bit 2
-#define LCD_DATA3_PIN    7            //< pin for 4bit data bit 3
-#define LCD_RS_PORT      LCD_PORT     //< port for RS line
-#define LCD_RS_PIN       3            //< pin  for RS line
-#define LCD_RW_PORT      LCD_PORT     //< port for RW line
-#define LCD_RW_PIN       2            //< pin  for RW line
-#define LCD_E_PORT       LCD_PORT     //< port for Enable line
-#define LCD_E_PIN        1            //< pin  for Enable line
-#endif
-*/
--- a/keyboards/40percentclub/6lit/rules.mk
+++ b/keyboards/40percentclub/6lit/rules.mk
@ -30,7 +30,6 @@ UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
-HD44780_ENABLE = no 		    # Enable support for HD44780 based LCDs

 # Enable generic behavior for split boards
 SPLIT_KEYBOARD = yes
--- a/keyboards/40percentclub/foobar/config.h
+++ b/keyboards/40percentclub/foobar/config.h
@ -198,31 +198,3 @@

 /* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
 //#define MIDI_TONE_KEYCODE_OCTAVES 1
-
-/*
- * HD44780 LCD Display Configuration
- */
-/*
-#define LCD_LINES           2     //< number of visible lines of the display
-#define LCD_DISP_LENGTH    16     //< visibles characters per line of the display
-
-#define LCD_IO_MODE      1            //< 0: memory mapped mode, 1: IO port mode
-
-#if LCD_IO_MODE
-#define LCD_PORT         PORTB        //< port for the LCD lines
-#define LCD_DATA0_PORT   LCD_PORT     //< port for 4bit data bit 0
-#define LCD_DATA1_PORT   LCD_PORT     //< port for 4bit data bit 1
-#define LCD_DATA2_PORT   LCD_PORT     //< port for 4bit data bit 2
-#define LCD_DATA3_PORT   LCD_PORT     //< port for 4bit data bit 3
-#define LCD_DATA0_PIN    4            //< pin for 4bit data bit 0
-#define LCD_DATA1_PIN    5            //< pin for 4bit data bit 1
-#define LCD_DATA2_PIN    6            //< pin for 4bit data bit 2
-#define LCD_DATA3_PIN    7            //< pin for 4bit data bit 3
-#define LCD_RS_PORT      LCD_PORT     //< port for RS line
-#define LCD_RS_PIN       3            //< pin  for RS line
-#define LCD_RW_PORT      LCD_PORT     //< port for RW line
-#define LCD_RW_PIN       2            //< pin  for RW line
-#define LCD_E_PORT       LCD_PORT     //< port for Enable line
-#define LCD_E_PIN        1            //< pin  for Enable line
-#endif
-*/
--- a/keyboards/40percentclub/foobar/rules.mk
+++ b/keyboards/40percentclub/foobar/rules.mk
@ -30,7 +30,6 @@ UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
-HD44780_ENABLE = no 		    # Enable support for HD44780 based LCDs

 # Enable generic behavior for split boards
 SPLIT_KEYBOARD = yes
--- a/keyboards/40percentclub/gherkin/keymaps/stevexyz/rules.mk
+++ b/keyboards/40percentclub/gherkin/keymaps/stevexyz/rules.mk
@ -11,7 +11,6 @@ UNICODE_ENABLE = no          # Unicode
 BLUETOOTH_ENABLE = no        # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no            # Audio output on port C6
 FAUXCLICKY_ENABLE = no       # Use buzzer to emulate clicky switches
-HD44780_ENABLE = no          # Enable support for HD44780 based LCDs
 TAP_DANCE_ENABLE = no
 SLEEP_LED_ENABLE = no       # Breathing sleep LED during USB suspend (it uses the same timer as BACKLIGHT_ENABLE)

--- a/keyboards/40percentclub/half_n_half/config.h
+++ b/keyboards/40percentclub/half_n_half/config.h
@ -212,34 +212,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
 //#define MIDI_TONE_KEYCODE_OCTAVES 1

-/*
- * HD44780 LCD Display Configuration
- */
-/*
-#define LCD_LINES           2     //< number of visible lines of the display
-#define LCD_DISP_LENGTH    16     //< visibles characters per line of the display
-
-#define LCD_IO_MODE      1            //< 0: memory mapped mode, 1: IO port mode
-
-#if LCD_IO_MODE
-#define LCD_PORT         PORTB        //< port for the LCD lines
-#define LCD_DATA0_PORT   LCD_PORT     //< port for 4bit data bit 0
-#define LCD_DATA1_PORT   LCD_PORT     //< port for 4bit data bit 1
-#define LCD_DATA2_PORT   LCD_PORT     //< port for 4bit data bit 2
-#define LCD_DATA3_PORT   LCD_PORT     //< port for 4bit data bit 3
-#define LCD_DATA0_PIN    4            //< pin for 4bit data bit 0
-#define LCD_DATA1_PIN    5            //< pin for 4bit data bit 1
-#define LCD_DATA2_PIN    6            //< pin for 4bit data bit 2
-#define LCD_DATA3_PIN    7            //< pin for 4bit data bit 3
-#define LCD_RS_PORT      LCD_PORT     //< port for RS line
-#define LCD_RS_PIN       3            //< pin  for RS line
-#define LCD_RW_PORT      LCD_PORT     //< port for RW line
-#define LCD_RW_PIN       2            //< pin  for RW line
-#define LCD_E_PORT       LCD_PORT     //< port for Enable line
-#define LCD_E_PIN        1            //< pin  for Enable line
-#endif
-*/
-
 /* Bootmagic Lite key configuration */
 // #define BOOTMAGIC_LITE_ROW 0
 // #define BOOTMAGIC_LITE_COLUMN 0
--- a/keyboards/40percentclub/half_n_half/rules.mk
+++ b/keyboards/40percentclub/half_n_half/rules.mk
@ -30,7 +30,6 @@ UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
-HD44780_ENABLE = no 		# Enable support for HD44780 based LCDs

 # Enable generic behavior for split boards
 SPLIT_KEYBOARD = yes
--- a/keyboards/40percentclub/i75/config.h
+++ b/keyboards/40percentclub/i75/config.h
@ -154,34 +154,6 @@
 /* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
 //#define MIDI_TONE_KEYCODE_OCTAVES 1

-/*
- * HD44780 LCD Display Configuration
- */
-/*
-#define LCD_LINES           2     //< number of visible lines of the display
-#define LCD_DISP_LENGTH    16     //< visibles characters per line of the display
-
-#define LCD_IO_MODE      1            //< 0: memory mapped mode, 1: IO port mode
-
-#if LCD_IO_MODE
-#define LCD_PORT         PORTB        //< port for the LCD lines
-#define LCD_DATA0_PORT   LCD_PORT     //< port for 4bit data bit 0
-#define LCD_DATA1_PORT   LCD_PORT     //< port for 4bit data bit 1
-#define LCD_DATA2_PORT   LCD_PORT     //< port for 4bit data bit 2
-#define LCD_DATA3_PORT   LCD_PORT     //< port for 4bit data bit 3
-#define LCD_DATA0_PIN    4            //< pin for 4bit data bit 0
-#define LCD_DATA1_PIN    5            //< pin for 4bit data bit 1
-#define LCD_DATA2_PIN    6            //< pin for 4bit data bit 2
-#define LCD_DATA3_PIN    7            //< pin for 4bit data bit 3
-#define LCD_RS_PORT      LCD_PORT     //< port for RS line
-#define LCD_RS_PIN       3            //< pin  for RS line
-#define LCD_RW_PORT      LCD_PORT     //< port for RW line
-#define LCD_RW_PIN       2            //< pin  for RW line
-#define LCD_E_PORT       LCD_PORT     //< port for Enable line
-#define LCD_E_PIN        1            //< pin  for Enable line
-#endif
-*/
-
 /* Bootmagic Lite key configuration */
 // #define BOOTMAGIC_LITE_ROW 0
 // #define BOOTMAGIC_LITE_COLUMN 0
--- a/keyboards/40percentclub/i75/rules.mk
+++ b/keyboards/40percentclub/i75/rules.mk
@ -17,7 +17,6 @@ UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
-HD44780_ENABLE = no 		    # Enable support for HD44780 based LCDs

 LAYOUTS = ortho_5x15
 DEFAULT_FOLDER = 40percentclub/i75/promicro
--- a/keyboards/40percentclub/nein/config.h
+++ b/keyboards/40percentclub/nein/config.h
@ -208,32 +208,6 @@
 /* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
 //#define MIDI_TONE_KEYCODE_OCTAVES 1

-/*
- * HD44780 LCD Display Configuration
- */
-/*
-#define LCD_LINES           2     //< number of visible lines of the display
-#define LCD_DISP_LENGTH    16     //< visibles characters per line of the display
-#define LCD_IO_MODE      1            //< 0: memory mapped mode, 1: IO port mode
-#if LCD_IO_MODE
-#define LCD_PORT         PORTB        //< port for the LCD lines
-#define LCD_DATA0_PORT   LCD_PORT     //< port for 4bit data bit 0
-#define LCD_DATA1_PORT   LCD_PORT     //< port for 4bit data bit 1
-#define LCD_DATA2_PORT   LCD_PORT     //< port for 4bit data bit 2
-#define LCD_DATA3_PORT   LCD_PORT     //< port for 4bit data bit 3
-#define LCD_DATA0_PIN    4            //< pin for 4bit data bit 0
-#define LCD_DATA1_PIN    5            //< pin for 4bit data bit 1
-#define LCD_DATA2_PIN    6            //< pin for 4bit data bit 2
-#define LCD_DATA3_PIN    7            //< pin for 4bit data bit 3
-#define LCD_RS_PORT      LCD_PORT     //< port for RS line
-#define LCD_RS_PIN       3            //< pin  for RS line
-#define LCD_RW_PORT      LCD_PORT     //< port for RW line
-#define LCD_RW_PIN       2            //< pin  for RW line
-#define LCD_E_PORT       LCD_PORT     //< port for Enable line
-#define LCD_E_PIN        1            //< pin  for Enable line
-#endif
-*/
-
 /* Bootmagic Lite key configuration */
 // #define BOOTMAGIC_LITE_ROW 0
 // #define BOOTMAGIC_LITE_COLUMN 0
--- a/keyboards/40percentclub/nein/rules.mk
+++ b/keyboards/40percentclub/nein/rules.mk
@ -30,4 +30,3 @@ UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
-HD44780_ENABLE = no 	    # Enable support for HD44780 based LCDs
--- a/keyboards/40percentclub/nori/config.h
+++ b/keyboards/40percentclub/nori/config.h
@ -186,31 +186,3 @@

 /* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
 //#define MIDI_TONE_KEYCODE_OCTAVES 1
-
-/*
- * HD44780 LCD Display Configuration
- */
-/*
-#define LCD_LINES           2     //< number of visible lines of the display
-#define LCD_DISP_LENGTH    16     //< visibles characters per line of the display
-
-#define LCD_IO_MODE      1            //< 0: memory mapped mode, 1: IO port mode
-
-#if LCD_IO_MODE
-#define LCD_PORT         PORTB        //< port for the LCD lines
-#define LCD_DATA0_PORT   LCD_PORT     //< port for 4bit data bit 0
-#define LCD_DATA1_PORT   LCD_PORT     //< port for 4bit data bit 1
-#define LCD_DATA2_PORT   LCD_PORT     //< port for 4bit data bit 2
-#define LCD_DATA3_PORT   LCD_PORT     //< port for 4bit data bit 3
-#define LCD_DATA0_PIN    4            //< pin for 4bit data bit 0
-#define LCD_DATA1_PIN    5            //< pin for 4bit data bit 1
-#define LCD_DATA2_PIN    6            //< pin for 4bit data bit 2
-#define LCD_DATA3_PIN    7            //< pin for 4bit data bit 3
-#define LCD_RS_PORT      LCD_PORT     //< port for RS line
-#define LCD_RS_PIN       3            //< pin  for RS line
-#define LCD_RW_PORT      LCD_PORT     //< port for RW line
-#define LCD_RW_PIN       2            //< pin  for RW line
-#define LCD_E_PORT       LCD_PORT     //< port for Enable line
-#define LCD_E_PIN        1            //< pin  for Enable line
-#endif
-*/
--- a/keyboards/40percentclub/nori/rules.mk
+++ b/keyboards/40percentclub/nori/rules.mk
@ -30,6 +30,5 @@ UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
-HD44780_ENABLE = no 		    # Enable support for HD44780 based LCDs

 LAYOUTS = ortho_4x4  ortho_4x8  ortho_4x12
--- a/keyboards/7skb/keymaps/via/keymap.c
+++ b/keyboards/7skb/keymaps/via/keymap.c
@ -0,0 +1,92 @@
+#include QMK_KEYBOARD_H
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+enum layer_number {
+  _BASE = 0,
+  _L1,
+  _L2,
+  _L3,
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  [_BASE] = LAYOUT(
+  //,-----------------------------------------------------|   |--------------------------------------------------------------------------------.
+       KC_ESC,    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_BSLS,  KC_GRV,
+  //|--------+--------+--------+--------+--------+--------|   |--------+--------+--------+--------+--------+--------+--------+--------+--------|
+       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_BSPC,
+  //|--------+--------+--------+--------+--------+--------|   |--------+--------+--------+--------+--------+--------+--------+--------|
+     KC_LCTRL,    KC_A,    KC_S,    KC_D,    KC_F,    KC_G,        KC_H,    KC_J,    KC_K,    KC_L, KC_SCLN, KC_QUOT,  KC_ENT,
+  //|--------+--------+--------+--------+--------+--------|   |--------+--------+--------+--------+--------+--------+--------|
+      KC_LSFT,    KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,        KC_N,    KC_M, KC_COMM,  KC_DOT, KC_SLSH, KC_RSFT, MO(_L1),
+  //|--------+--------+--------+--------+--------+--------|   |--------+--------+--------+--------+--------+--------+--------|
+               KC_LALT, KC_LGUI,  KC_SPC,  KC_SPC,               KC_SPC,  KC_SPC,          KC_RGUI, KC_RALT 
+          //`---------------------------------------------|   |--------------------------------------------'
+  ),
+
+  [_L1] = LAYOUT(
+  //,-----------------------------------------------------|   |--------------------------------------------------------------------------------.
+  TG(_L2),   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_INS,  KC_DEL,
+  //|--------+--------+--------+--------+--------+--------|   |--------+--------+--------+--------+--------+--------+--------+--------+--------|
+      _______, _______, _______, _______, _______, _______,     _______, _______, KC_PSCR, KC_SLCK,KC_PAUSE,   KC_UP, _______, KC_BSPC,
+  //|--------+--------+--------+--------+--------+--------|   |--------+--------+--------+--------+--------+--------+--------+--------|
+      _______, _______, _______, _______, _______, _______,     _______, _______, KC_HOME, KC_PGUP, KC_LEFT,KC_RIGHT, _______,
+  //|--------+--------+--------+--------+--------+--------|   |--------+--------+--------+--------+--------+--------+--------|
+      _______, _______, _______, _______, _______, _______,     _______, _______,  KC_END, KC_PGDN, KC_DOWN, _______, _______,
+  //|--------+--------+--------+--------+--------+--------|   |--------+--------+--------+--------+--------+--------+--------|
+               _______, _______, _______, _______,              _______, _______,          KC_STOP, _______ 
+          //`---------------------------------------------|   |--------------------------------------------'
+  ),
+
+  [_L2] = LAYOUT( /* Base */
+  //,-----------------------------------------------------|   |--------------------------------------------------------------------------------.
+ TG(_L2), XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,     XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,   RESET,
+  //|--------+--------+--------+--------+--------+--------|   |--------+--------+--------+--------+--------+--------+--------+--------+--------|
+      XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,     XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
+  //|--------+--------+--------+--------+--------+--------|   |--------+--------+--------+--------+--------+--------+--------+--------|
+      XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,     RGB_TOG, RGB_MOD, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
+  //|--------+--------+--------+--------+--------+--------|   |--------+--------+--------+--------+--------+--------+--------|
+      XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,     RGB_VAD, RGB_VAI, RGB_HUD, RGB_HUI, RGB_SAD, RGB_SAI, XXXXXXX,
+  //|--------+--------+--------+--------+--------+--------|   |--------+--------+--------+--------+--------+--------+--------|
+               XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,              XXXXXXX, XXXXXXX,          KC_STOP, XXXXXXX 
+          //`---------------------------------------------|   |--------------------------------------------'
+  ),
+  
+  [_L3] = LAYOUT( /* Base */
+  //,-----------------------------------------------------|   |--------------------------------------------------------------------------------.
+      XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,     XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,   RESET,
+  //|--------+--------+--------+--------+--------+--------|   |--------+--------+--------+--------+--------+--------+--------+--------+--------|
+      XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,     XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
+  //|--------+--------+--------+--------+--------+--------|   |--------+--------+--------+--------+--------+--------+--------+--------|
+      XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,     XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
+  //|--------+--------+--------+--------+--------+--------|   |--------+--------+--------+--------+--------+--------+--------|
+      XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,     XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
+  //|--------+--------+--------+--------+--------+--------|   |--------+--------+--------+--------+--------+--------+--------|
+               XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,              XXXXXXX, XXXXXXX,          XXXXXXX, XXXXXXX 
+          //`---------------------------------------------|   |--------------------------------------------'
+  )
+};
+
+
+//A description for expressing the layer position in LED mode.
+layer_state_t layer_state_set_user(layer_state_t state) {
+#ifdef RGBLIGHT_ENABLE
+    switch (get_highest_layer(state)) {
+    case _L1:
+      rgblight_sethsv_at(HSV_BLUE, 0);
+      break;
+    case _L2:
+      rgblight_sethsv_at(HSV_RED, 0);
+      break;
+    case _L3:
+      rgblight_sethsv_at(HSV_PURPLE, 0);
+      break;
+    default: //  for any other layers, or the default layer
+      rgblight_sethsv_at( 0, 0, 0, 0);
+      break;
+    }
+    rgblight_set_effect_range( 1, 5);
+#endif
+return state;
+}
--- a/keyboards/7skb/keymaps/via/readme.md
+++ b/keyboards/7skb/keymaps/via/readme.md
@ -0,0 +1,3 @@
+# The via keymap for 7sKB
+
+The basic keymap with full support for VIA Configurator
--- a/keyboards/7skb/keymaps/via/rules.mk
+++ b/keyboards/7skb/keymaps/via/rules.mk
@ -0,0 +1 @@
+VIA_ENABLE = yes
--- a/keyboards/7skb/rev1/config.h
+++ b/keyboards/7skb/rev1/config.h
@ -19,8 +19,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #pragma once

 /* USB Device descriptor parameter */
-#define VENDOR_ID       0xFEED
-#define PRODUCT_ID      0x36E1
+#define VENDOR_ID       0x04D8
+#define PRODUCT_ID      0xEB5F
 #define DEVICE_VER      0x0007
 #define MANUFACTURER    Salicylic_Acid
 #define PRODUCT         7skb
--- a/keyboards/abacus/rules.mk
+++ b/keyboards/abacus/rules.mk
@ -29,7 +29,6 @@ MIDI_ENABLE = no            # MIDI support
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
-HD44780_ENABLE = no         # Enable support for HD44780 based LCDs
 UNICODEMAP_ENABLE = yes
 ENCODER_ENABLE = yes
 DIP_SWITCH_ENABLE = yes
--- a/keyboards/abstract/ellipse/rev1/config.h
+++ b/keyboards/abstract/ellipse/rev1/config.h
@ -202,34 +202,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
 //#define MIDI_TONE_KEYCODE_OCTAVES 1

-/*
- * HD44780 LCD Display Configuration
- */
-/*
-#define LCD_LINES           2     //< number of visible lines of the display
-#define LCD_DISP_LENGTH    16     //< visibles characters per line of the display
-
-#define LCD_IO_MODE      1            //< 0: memory mapped mode, 1: IO port mode
-
-#if LCD_IO_MODE
-#define LCD_PORT         PORTB        //< port for the LCD lines
-#define LCD_DATA0_PORT   LCD_PORT     //< port for 4bit data bit 0
-#define LCD_DATA1_PORT   LCD_PORT     //< port for 4bit data bit 1
-#define LCD_DATA2_PORT   LCD_PORT     //< port for 4bit data bit 2
-#define LCD_DATA3_PORT   LCD_PORT     //< port for 4bit data bit 3
-#define LCD_DATA0_PIN    4            //< pin for 4bit data bit 0
-#define LCD_DATA1_PIN    5            //< pin for 4bit data bit 1
-#define LCD_DATA2_PIN    6            //< pin for 4bit data bit 2
-#define LCD_DATA3_PIN    7            //< pin for 4bit data bit 3
-#define LCD_RS_PORT      LCD_PORT     //< port for RS line
-#define LCD_RS_PIN       3            //< pin  for RS line
-#define LCD_RW_PORT      LCD_PORT     //< port for RW line
-#define LCD_RW_PIN       2            //< pin  for RW line
-#define LCD_E_PORT       LCD_PORT     //< port for Enable line
-#define LCD_E_PIN        1            //< pin  for Enable line
-#endif
-*/
-
 /* Bootmagic Lite key configuration */
 // #define BOOTMAGIC_LITE_ROW 0
 // #define BOOTMAGIC_LITE_COLUMN 0
--- a/keyboards/abstract/ellipse/rev1/rules.mk
+++ b/keyboards/abstract/ellipse/rev1/rules.mk
@ -30,5 +30,4 @@ UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
-HD44780_ENABLE = no 		# Enable support for HD44780 based LCDs
 ENCODER_ENABLE = yes		# Enable support for rotary encoders
--- a/keyboards/acheron/austin/rules.mk
+++ b/keyboards/acheron/austin/rules.mk
@ -19,7 +19,6 @@ MIDI_ENABLE = no            # MIDI support
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
-HD44780_ENABLE = no         # Enable support for HD44780 based LCDs

 # Enter lower-power sleep mode when on the ChibiOS idle thread
 OPT_DEFS += -DCORTEX_ENABLE_WFI_IDLE=TRUE
--- a/keyboards/acheron/elongate/config.h
+++ b/keyboards/acheron/elongate/config.h
@ -217,34 +217,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
 //#define MIDI_TONE_KEYCODE_OCTAVES 1

-/*
- * HD44780 LCD Display Configuration
- */
-/*
-#define LCD_LINES           2     //< number of visible lines of the display
-#define LCD_DISP_LENGTH    16     //< visibles characters per line of the display
-
-#define LCD_IO_MODE      1            //< 0: memory mapped mode, 1: IO port mode
-
-#if LCD_IO_MODE
-#define LCD_PORT         PORTB        //< port for the LCD lines
-#define LCD_DATA0_PORT   LCD_PORT     //< port for 4bit data bit 0
-#define LCD_DATA1_PORT   LCD_PORT     //< port for 4bit data bit 1
-#define LCD_DATA2_PORT   LCD_PORT     //< port for 4bit data bit 2
-#define LCD_DATA3_PORT   LCD_PORT     //< port for 4bit data bit 3
-#define LCD_DATA0_PIN    4            //< pin for 4bit data bit 0
-#define LCD_DATA1_PIN    5            //< pin for 4bit data bit 1
-#define LCD_DATA2_PIN    6            //< pin for 4bit data bit 2
-#define LCD_DATA3_PIN    7            //< pin for 4bit data bit 3
-#define LCD_RS_PORT      LCD_PORT     //< port for RS line
-#define LCD_RS_PIN       3            //< pin  for RS line
-#define LCD_RW_PORT      LCD_PORT     //< port for RW line
-#define LCD_RW_PIN       2            //< pin  for RW line
-#define LCD_E_PORT       LCD_PORT     //< port for Enable line
-#define LCD_E_PIN        1            //< pin  for Enable line
-#endif
-*/
-
 /* Bootmagic Lite key configuration */
 // #define BOOTMAGIC_LITE_ROW 0
 // #define BOOTMAGIC_LITE_COLUMN 0
--- a/keyboards/acheron/elongate/rules.mk
+++ b/keyboards/acheron/elongate/rules.mk
@ -29,6 +29,5 @@ MIDI_ENABLE = no            # MIDI support
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
-HD44780_ENABLE = no         # Enable support for HD44780 based LCDs

 LTO_ENABLE = yes
--- a/keyboards/acheron/keebspcb/rules.mk
+++ b/keyboards/acheron/keebspcb/rules.mk
@ -19,7 +19,6 @@ MIDI_ENABLE = no            # MIDI support
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
-HD44780_ENABLE = no         # Enable support for HD44780 based LCDs

 # Enter lower-power sleep mode when on the ChibiOS idle thread
 OPT_DEFS += -DCORTEX_ENABLE_WFI_IDLE=TRUE
--- a/keyboards/acheron/shark/config.h
+++ b/keyboards/acheron/shark/config.h
@ -228,34 +228,6 @@ B0, which is unconnected on the PCB
 /* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
 //#define MIDI_TONE_KEYCODE_OCTAVES 1

-/*
- * HD44780 LCD Display Configuration
- */
-/*
-#define LCD_LINES           2     //< number of visible lines of the display
-#define LCD_DISP_LENGTH    16     //< visibles characters per line of the display
-
-#define LCD_IO_MODE      1            //< 0: memory mapped mode, 1: IO port mode
-
-#if LCD_IO_MODE
-#define LCD_PORT         PORTB        //< port for the LCD lines
-#define LCD_DATA0_PORT   LCD_PORT     //< port for 4bit data bit 0
-#define LCD_DATA1_PORT   LCD_PORT     //< port for 4bit data bit 1
-#define LCD_DATA2_PORT   LCD_PORT     //< port for 4bit data bit 2
-#define LCD_DATA3_PORT   LCD_PORT     //< port for 4bit data bit 3
-#define LCD_DATA0_PIN    4            //< pin for 4bit data bit 0
-#define LCD_DATA1_PIN    5            //< pin for 4bit data bit 1
-#define LCD_DATA2_PIN    6            //< pin for 4bit data bit 2
-#define LCD_DATA3_PIN    7            //< pin for 4bit data bit 3
-#define LCD_RS_PORT      LCD_PORT     //< port for RS line
-#define LCD_RS_PIN       3            //< pin  for RS line
-#define LCD_RW_PORT      LCD_PORT     //< port for RW line
-#define LCD_RW_PIN       2            //< pin  for RW line
-#define LCD_E_PORT       LCD_PORT     //< port for Enable line
-#define LCD_E_PIN        1            //< pin  for Enable line
-#endif
-*/
-
 /* Bootmagic Lite key configuration */
 // #define BOOTMAGIC_LITE_ROW 0
 // #define BOOTMAGIC_LITE_COLUMN 0
--- a/keyboards/acheron/shark/rules.mk
+++ b/keyboards/acheron/shark/rules.mk
@ -20,6 +20,5 @@ UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
-HD44780_ENABLE = no 		# Enable support for HD44780 based LCDs

 LAYOUTS = ortho_4x12
--- a/keyboards/adelheid/adelheid.c
+++ b/keyboards/adelheid/adelheid.c
@ -0,0 +1,16 @@
+/* Copyright 2020 floookay
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "adelheid.h"
--- a/keyboards/adelheid/adelheid.h
+++ b/keyboards/adelheid/adelheid.h
@ -0,0 +1,45 @@
+/* Copyright 2020 floookay
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#include "quantum.h"
+
+/* This a shortcut to help you visually see your layout.
+ *
+ * The first section contains all of the arguments representing the physical
+ * layout of the board and position of the keys.
+ *
+ * The second converts the arguments into a two-dimensional array which
+ * represents the switch matrix.
+ */
+#define LAYOUT( \
+	k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0A, k0B, k0C,      k0D, k0E, \
+	                                                                                \
+	k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1A, k1B, k1C, k1D, k1E, k2E, \
+	k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k2A, k2B, k2C, k2D,      k3E, \
+	k30, k31, k32, k33, k34, k35, k36, k37, k38, k39, k3A, k3B, k3C,           k4E, \
+	k40, k41, k42, k43, k44, k45, k46, k47, k48, k49, k4A, k4B,      k4D,           \
+	k50,      k52,      k54, k55,      k57,      k59,           k5C, k5D, k5E       \
+) \
+{ \
+	{ k00,   k01,   k02,   k03,   k04,   k05,   k06,   k07,   k08,   k09,   k0A,   k0B,   k0C,   k0D,   k0E   }, \
+	{ KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
+	{ k10,   k11,   k12,   k13,   k14,   k15,   k16,   k17,   k18,   k19,   k1A,   k1B,   k1C,   k1D,   k1E   }, \
+	{ k20,   k21,   k22,   k23,   k24,   k25,   k26,   k27,   k28,   k29,   k2A,   k2B,   k2C,   k2D,   k2E   }, \
+	{ k30,   k31,   k32,   k33,   k34,   k35,   k36,   k37,   k38,   k39,   k3A,   k3B,   k3C,   KC_NO, k3E   }, \
+	{ k40,   k41,   k42,   k43,   k44,   k45,   k46,   k47,   k48,   k49,   k4A,   k4B,   KC_NO, k4D,   k4E   }, \
+	{ k50,   KC_NO, k52,   KC_NO, k54,   k55,   KC_NO, k57,   KC_NO, k59,   KC_NO, KC_NO, k5C,   k5D,   k5E   }  \
+}
--- a/keyboards/adelheid/config.h
+++ b/keyboards/adelheid/config.h
@ -0,0 +1,208 @@
+/*
+Copyright 2020 floookay
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include "config_common.h"
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID       0xF100
+#define PRODUCT_ID      0xAD78
+#define DEVICE_VER      0x0002
+#define MANUFACTURER    floookay
+#define PRODUCT         adelheid
+#define DESCRIPTION     75% alice-like keyboard based on the arisu
+
+/* key matrix size */
+#define MATRIX_ROWS 7
+#define MATRIX_COLS 15
+
+/*
+ * Keyboard Matrix Assignments
+ *
+ * Change this to how you wired your keyboard
+ * COLS: AVR pins used for columns, left to right
+ * ROWS: AVR pins used for rows, top to bottom
+ * DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode)
+ *                  ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
+ *
+*/
+#define MATRIX_ROW_PINS { D0, F4, D1, D2, D3, D5, F7 }
+#define MATRIX_COL_PINS { F0, F1, E6, C7, F6, B6, D4, B1, B0, B7, B5, B4, D7, D6, B3 }
+#define UNUSED_PINS
+
+/* COL2ROW, ROW2COL*/
+#define DIODE_DIRECTION COL2ROW
+
+#define BACKLIGHT_PIN C6
+// #define BACKLIGHT_BREATHING
+#define BACKLIGHT_LEVELS 3
+
+// #define RGB_DI_PIN E2
+// #ifdef RGB_DI_PIN
+//   #define RGBLED_NUM 16
+//   #define RGBLIGHT_HUE_STEP 8
+//   #define RGBLIGHT_SAT_STEP 8
+//   #define RGBLIGHT_VAL_STEP 8
+//   #define RGBLIGHT_LIMIT_VAL 255 /* The maximum brightness level */
+//   #define RGBLIGHT_SLEEP  /* If defined, the RGB lighting will be switched off when the host goes to sleep */
+// /*== all animations enable ==*/
+//   #define RGBLIGHT_ANIMATIONS
+// /*== or choose animations ==*/
+//   #define RGBLIGHT_EFFECT_BREATHING
+//   #define RGBLIGHT_EFFECT_RAINBOW_MOOD
+//   #define RGBLIGHT_EFFECT_RAINBOW_SWIRL
+//   #define RGBLIGHT_EFFECT_SNAKE
+//   #define RGBLIGHT_EFFECT_KNIGHT
+//   #define RGBLIGHT_EFFECT_CHRISTMAS
+//   #define RGBLIGHT_EFFECT_STATIC_GRADIENT
+//   #define RGBLIGHT_EFFECT_RGB_TEST
+//   #define RGBLIGHT_EFFECT_ALTERNATING
+// #endif
+
+/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
+#define DEBOUNCE 5
+
+/* define if matrix has ghost (lacks anti-ghosting diodes) */
+//#define MATRIX_HAS_GHOST
+
+/* number of backlight levels */
+
+/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
+#define LOCKING_SUPPORT_ENABLE
+/* Locking resynchronize hack */
+#define LOCKING_RESYNC_ENABLE
+
+/* If defined, GRAVE_ESC will always act as ESC when CTRL is held.
+ * This is userful for the Windows task manager shortcut (ctrl+shift+esc).
+ */
+// #define GRAVE_ESC_CTRL_OVERRIDE
+
+/*
+ * Force NKRO
+ *
+ * Force NKRO (nKey Rollover) to be enabled by default, regardless of the saved
+ * state in the bootmagic EEPROM settings. (Note that NKRO must be enabled in the
+ * makefile for this to work.)
+ *
+ * If forced on, NKRO can be disabled via magic key (default = LShift+RShift+N)
+ * until the next keyboard reset.
+ *
+ * NKRO may prevent your keystrokes from being detected in the BIOS, but it is
+ * fully operational during normal computer usage.
+ *
+ * For a less heavy-handed approach, enable NKRO via magic key (LShift+RShift+N)
+ * or via bootmagic (hold SPACE+N while plugging in the keyboard). Once set by
+ * bootmagic, NKRO mode will always be enabled until it is toggled again during a
+ * power-up.
+ *
+ */
+//#define FORCE_NKRO
+
+/*
+ * Magic Key Options
+ *
+ * Magic keys are hotkey commands that allow control over firmware functions of
+ * the keyboard. They are best used in combination with the HID Listen program,
+ * found here: https://www.pjrc.com/teensy/hid_listen.html
+ *
+ * The options below allow the magic key functionality to be changed. This is
+ * useful if your keyboard/keypad is missing keys and you want magic key support.
+ *
+ */
+
+/* key combination for magic key command */
+/* defined by default; to change, uncomment and set to the combination you want */
+// #define IS_COMMAND() (get_mods() == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)))
+
+/* control how magic key switches layers */
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS  true
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS  true
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM false
+
+/* override magic key keymap */
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS
+//#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM
+//#define MAGIC_KEY_HELP           H
+//#define MAGIC_KEY_HELP_ALT       SLASH
+//#define MAGIC_KEY_DEBUG          D
+//#define MAGIC_KEY_DEBUG_MATRIX   X
+//#define MAGIC_KEY_DEBUG_KBD      K
+//#define MAGIC_KEY_DEBUG_MOUSE    M
+//#define MAGIC_KEY_VERSION        V
+//#define MAGIC_KEY_STATUS         S
+//#define MAGIC_KEY_CONSOLE        C
+//#define MAGIC_KEY_LAYER0         0
+//#define MAGIC_KEY_LAYER0_ALT     GRAVE
+//#define MAGIC_KEY_LAYER1         1
+//#define MAGIC_KEY_LAYER2         2
+//#define MAGIC_KEY_LAYER3         3
+//#define MAGIC_KEY_LAYER4         4
+//#define MAGIC_KEY_LAYER5         5
+//#define MAGIC_KEY_LAYER6         6
+//#define MAGIC_KEY_LAYER7         7
+//#define MAGIC_KEY_LAYER8         8
+//#define MAGIC_KEY_LAYER9         9
+//#define MAGIC_KEY_BOOTLOADER     B
+//#define MAGIC_KEY_BOOTLOADER_ALT ESC
+//#define MAGIC_KEY_LOCK           CAPS
+//#define MAGIC_KEY_EEPROM         E
+//#define MAGIC_KEY_EEPROM_CLEAR   BSPACE
+//#define MAGIC_KEY_NKRO           N
+//#define MAGIC_KEY_SLEEP_LED      Z
+
+/*
+ * Feature disable options
+ *  These options are also useful to firmware size reduction.
+ */
+
+/* disable debug print */
+//#define NO_DEBUG
+
+/* disable print */
+//#define NO_PRINT
+
+/* disable action features */
+//#define NO_ACTION_LAYER
+//#define NO_ACTION_TAPPING
+//#define NO_ACTION_ONESHOT
+//#define NO_ACTION_MACRO
+//#define NO_ACTION_FUNCTION
+
+/*
+ * MIDI options
+ */
+
+/* Prevent use of disabled MIDI features in the keymap */
+//#define MIDI_ENABLE_STRICT 1
+
+/* enable basic MIDI features:
+   - MIDI notes can be sent when in Music mode is on
+*/
+//#define MIDI_BASIC
+
+/* enable advanced MIDI features:
+   - MIDI notes can be added to the keymap
+   - Octave shift and transpose
+   - Virtual sustain, portamento, and modulation wheel
+   - etc.
+*/
+//#define MIDI_ADVANCED
+
+/* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
+//#define MIDI_TONE_KEYCODE_OCTAVES 1
--- a/keyboards/adelheid/info.json
+++ b/keyboards/adelheid/info.json
@ -0,0 +1,100 @@
+{
+    "keyboard_name": "Adelheid",
+    "url": "https://github.com/floookay/adelheid",
+    "maintainer": "floookay",
+    "width": 19.5,
+    "height": 6.5,
+    "layouts": {
+        "LAYOUT": {
+            "layout": [
+                { "label": "k00", "x": 0, "y": 0 },
+                { "label": "k01", "x": 1.25, "y": 0 },
+                { "label": "k02", "x": 2.25, "y": 0 },
+                { "label": "k03", "x": 3.5, "y": 0 },
+                { "label": "k04", "x": 4.5, "y": 0 },
+                { "label": "k05", "x": 5.75, "y": 0 },
+                { "label": "k06", "x": 6.75, "y": 0 },
+                { "label": "k07", "x": 9.75, "y": 0 },
+                { "label": "k08", "x": 10.75, "y": 0 },
+                { "label": "k09", "x": 12, "y": 0 },
+                { "label": "k0A", "x": 13, "y": 0 },
+                { "label": "k0B", "x": 14.25, "y": 0 },
+                { "label": "k0C", "x": 15.25, "y": 0 },
+                { "label": "k0D", "x": 16.5, "y": 0 },
+                { "label": "k0E", "x": 17.75, "y": 0 },
+
+                { "label": "k10", "x": 0.75, "y": 1.25 },
+                { "label": "k11", "x": 1.75, "y": 1.25 },
+                { "label": "k12", "x": 2.75, "y": 1.25 },
+                { "label": "k13", "x": 4, "y": 1.25 },
+                { "label": "k14", "x": 5, "y": 1.25 },
+                { "label": "k15", "x": 6, "y": 1.25 },
+                { "label": "k16", "x": 7, "y": 1.25 },
+                { "label": "k17", "x": 9.5, "y": 1.25 },
+                { "label": "k18", "x": 10.5, "y": 1.25 },
+                { "label": "k19", "x": 11.5, "y": 1.25 },
+                { "label": "k1A", "x": 12.5, "y": 1.25 },
+                { "label": "k1B", "x": 13.75, "y": 1.25 },
+                { "label": "k1C", "x": 14.75, "y": 1.25 },
+                { "label": "k1D", "x": 15.75, "y": 1.25 },
+                { "label": "k1E", "x": 16.75, "y": 1.25 },
+                { "label": "k2E", "x": 18, "y": 1 },
+
+                { "label": "k20", "x": 0.5, "y": 2.25, "w": 1.5 },
+                { "label": "k21", "x": 2, "y": 2.25 },
+                { "label": "k22", "x": 3.5, "y": 2.25 },
+                { "label": "k23", "x": 4.5, "y": 2.25 },
+                { "label": "k24", "x": 5.5, "y": 2.25 },
+                { "label": "k25", "x": 6.5, "y": 2.25 },
+                { "label": "k26", "x": 9, "y": 2.25 },
+                { "label": "k27", "x": 10, "y": 2.25 },
+                { "label": "k28", "x": 11, "y": 2.25 },
+                { "label": "k29", "x": 12, "y": 2.25 },
+                { "label": "k2A", "x": 13, "y": 2.25 },
+                { "label": "k2B", "x": 14.5, "y": 2.25 },
+                { "label": "k2C", "x": 15.5, "y": 2.25 },
+                { "label": "k2D", "x": 16.5, "y": 2.25, "w": 1.5 },
+                { "label": "k3E", "x": 18.25, "y": 2 },
+
+                { "label": "k30", "x": 0.25, "y": 3.25, "w": 1.75 },
+                { "label": "k31", "x": 2, "y": 3.25 },
+                { "label": "k32", "x": 3.75, "y": 3.25 },
+                { "label": "k33", "x": 4.75, "y": 3.25 },
+                { "label": "k34", "x": 5.75, "y": 3.25 },
+                { "label": "k35", "x": 6.75, "y": 3.25 },
+                { "label": "k36", "x": 9.25, "y": 3.25 },
+                { "label": "k37", "x": 10.25, "y": 3.25 },
+                { "label": "k38", "x": 11.25, "y": 3.25 },
+                { "label": "k39", "x": 12.25, "y": 3.25 },
+                { "label": "k3A", "x": 14, "y": 3.25 },
+                { "label": "k3B", "x": 15, "y": 3.25 },
+                { "label": "k3C", "x": 16, "y": 3.25, "w": 2.25 },
+                { "label": "k4E", "x": 18.5, "y": 3 },
+
+                { "label": "k40", "x": 0, "y": 4.25, "w": 2.25 },
+                { "label": "k41", "x": 2.25, "y": 4.25 },
+                { "label": "k42", "x": 4.25, "y": 4.25 },
+                { "label": "k43", "x": 5.25, "y": 4.25 },
+                { "label": "k44", "x": 6.25, "y": 4.25 },
+                { "label": "k45", "x": 7.25, "y": 4.25 },
+                { "label": "k46", "x": 9.5, "y": 4.25 },
+                { "label": "k47", "x": 10.5, "y": 4.25 },
+                { "label": "k48", "x": 11.5, "y": 4.25 },
+                { "label": "k49", "x": 12.5, "y": 4.25 },
+                { "label": "k4A", "x": 14.5, "y": 4.25 },
+                { "label": "k4B", "x": 15.5, "y": 4.25, "w": 1.75 },
+                { "label": "k4D", "x": 17.5, "y": 4.5 },
+
+                { "label": "k50", "x": 0, "y": 5.25, "w": 1.5 },
+                { "label": "k52", "x": 4.25, "y": 5.25, "w": 1.5 },
+                { "label": "k54", "x": 5.75, "y": 5.25, "w": 2 },
+                { "label": "k55", "x": 7.75, "y": 5.25 },
+                { "label": "k57", "x": 9, "y": 5.25, "w": 2.75 },
+                { "label": "k59", "x": 11.75, "y": 5.25, "w": 1.5 },
+                { "label": "k5C", "x": 16.5, "y": 5.5 },
+                { "label": "k5D", "x": 17.5, "y": 5.5 },
+                { "label": "k5E", "x": 18.5, "y": 5.5 }
+            ]
+        }
+    }
+}
--- a/keyboards/adelheid/keymaps/default/keymap.c
+++ b/keyboards/adelheid/keymaps/default/keymap.c
@ -0,0 +1,45 @@
+/* Copyright 2020 floookay
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include QMK_KEYBOARD_H
+
+enum adelheid_layers {
+  _BASE,
+  _SECONDARY
+};
+
+#define MO_SEC MO(_SECONDARY)
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  [_BASE] = LAYOUT(
+    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_F13,  KC_PGUP,
+
+    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_BSLS, KC_DEL,  KC_HOME,
+    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_BSPC,          KC_END,
+    KC_LCTL, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_ENT,                    KC_PGDN,
+    KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT,          KC_UP,
+    KC_LCTL,          KC_LALT,          KC_SPC,  MO_SEC,           KC_SPC,           KC_RALT,                   KC_LEFT, KC_DOWN, KC_RGHT
+  ),
+
+  [_SECONDARY] = LAYOUT(
+    KC_SLEP, KC_F13,  KC_F14,  KC_F15,  KC_F16,  KC_F17,  KC_F18,  KC_F19,  KC_F20,  KC_F21,  KC_F22,  KC_F23,  KC_F24,           KC_PSCR, KC_VOLU,
+
+    _______, 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_INS,  BL_STEP,
+    _______, _______, _______, _______, _______, _______, KC_HOME, KC_PGDN, KC_PGUP, KC_END,  _______, _______, _______, KC_DEL,           KC_MUTE,
+    KC_LGUI, _______, _______, _______, _______, _______, KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT, _______, _______, KC_MPLY,                   KC_VOLD,
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,          KC_MPLY,
+    _______,          _______,          _______, _______,          _______,          _______,                   KC_MPRV, KC_MSTP, KC_MNXT
+  )
+};
--- a/keyboards/adelheid/keymaps/default/readme.md
+++ b/keyboards/adelheid/keymaps/default/readme.md
@ -0,0 +1,9 @@
+# Default keymap for the Adelheid
+
+- ANSI QWERTY
+- split backspace
+- ctrl instead of caps lock
+- lgui on fn+caps
+
+![adelheid_layout](https://gist.githubusercontent.com/floookay/7bf6511a8d84804d32de4d7bbe3bd0fb/raw/dffd622a762463f341466ffecefad3b31ad3ee4f/layout.png)  
+View in [Keyboard-Layout-Editor](http://www.keyboard-layout-editor.com/#/gists/4262535adb5ac81a913edbebc4de8226).
--- a/keyboards/adelheid/keymaps/floookay/keymap.c
+++ b/keyboards/adelheid/keymaps/floookay/keymap.c
@ -0,0 +1,76 @@
+/* Copyright 2020 floookay
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include QMK_KEYBOARD_H
+
+enum adelheid_layers {
+  _BASE,
+  _SECONDARY
+};
+
+// tap dance declarations
+enum {
+    _TD_CTGU = 0,
+    _TD_PGUP = 1,
+    _TD_PGDN = 2,
+    _TD_HOME = 3,
+    _TD_END  = 4,
+    _TD_RSHC = 5,
+    _TD_PSCR = 6
+};
+
+#define MO_SEC MO(_SECONDARY)
+#define TD_CTGU TD(_TD_CTGU)
+#define TD_PGUP TD(_TD_PGUP)
+#define TD_PGDN TD(_TD_PGDN)
+#define TD_HOME TD(_TD_HOME)
+#define TD_END TD(_TD_END)
+#define TD_RSHC TD(_TD_RSHC)
+#define TD_PSCR TD(_TD_PSCR)
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  [_BASE] = LAYOUT(
+    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_F13,  TD_PGUP,
+
+    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_BSLS, KC_DEL,  TD_HOME,
+    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_BSPC,          TD_END,
+    TD_CTGU, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_ENT,                    TD_PGDN,
+    KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT,          KC_UP,
+    KC_LCTL,          KC_LALT,          KC_SPC,  MO_SEC,           KC_SPC,           KC_RALT,                   KC_LEFT, KC_DOWN, KC_RGHT
+  ),
+
+  [_SECONDARY] = LAYOUT(
+    KC_SLEP, KC_F13,  KC_F14,  KC_F15,  KC_F16,  KC_F17,  KC_F18,  KC_F19,  KC_F20,  KC_F21,  KC_F22,  KC_F23,  KC_F24,           TD_PSCR, KC_VOLU,
+
+    _______, 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_INS,  BL_STEP,
+    _______, _______, _______, _______, _______, _______, KC_HOME, KC_PGDN, KC_PGUP, KC_END,  _______, _______, _______, KC_DEL,           KC_MUTE,
+    _______, _______, _______, _______, _______, _______, KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT, _______, _______, KC_MPLY,                   KC_VOLD,
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, TD_RSHC,          KC_MPLY,
+    _______,          _______,          _______, _______,          _______,          _______,                   KC_MPRV, KC_MSTP, KC_MNXT
+  )
+};
+
+
+// Tap Dance Definitions
+qk_tap_dance_action_t tap_dance_actions[] = {
+    // Tap once for first parameter, twice for second
+    [_TD_CTGU] = ACTION_TAP_DANCE_DOUBLE(KC_LCTL, KC_LGUI),
+    [_TD_PGUP] = ACTION_TAP_DANCE_DOUBLE(KC_PGUP, LCTL(KC_PGUP)),
+    [_TD_PGDN] = ACTION_TAP_DANCE_DOUBLE(KC_PGDN, LCTL(KC_PGDN)),
+    [_TD_HOME] = ACTION_TAP_DANCE_DOUBLE(KC_HOME, LCTL(KC_HOME)),
+    [_TD_END]  = ACTION_TAP_DANCE_DOUBLE(KC_END,  LCTL(KC_END)),
+    [_TD_RSHC] = ACTION_TAP_DANCE_DOUBLE(KC_RSFT, KC_CAPS),
+    [_TD_PSCR] = ACTION_TAP_DANCE_DOUBLE(KC_PSCR, LSFT(LGUI(KC_S))) // screenshot tool tap dance
+};
--- a/keyboards/adelheid/keymaps/floookay/readme.md
+++ b/keyboards/adelheid/keymaps/floookay/readme.md
@ -0,0 +1,9 @@
+# The default keymap for the Adelheid
+
+- ANSI QWERTY
+- split backspace
+- ctrl on caps lock with super on tap dance
+- caps lock on fn + right shift tap dance
+
+![adelheid_layout](https://gist.githubusercontent.com/floookay/7bf6511a8d84804d32de4d7bbe3bd0fb/raw/dffd622a762463f341466ffecefad3b31ad3ee4f/layout.png)  
+View in [Keyboard-Layout-Editor](http://www.keyboard-layout-editor.com/#/gists/4262535adb5ac81a913edbebc4de8226).
--- a/keyboards/adelheid/keymaps/floookay/rules.mk
+++ b/keyboards/adelheid/keymaps/floookay/rules.mk
@ -0,0 +1 @@
+TAP_DANCE_ENABLE = yes
--- a/keyboards/adelheid/keymaps/via/keymap.c
+++ b/keyboards/adelheid/keymaps/via/keymap.c
@ -0,0 +1,54 @@
+/* Copyright 2020 floookay
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include QMK_KEYBOARD_H
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  [0] = LAYOUT(
+    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_F13,  KC_PGUP,
+    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_BSLS, KC_DEL,  KC_HOME,
+    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_BSPC,          KC_END,
+    KC_LCTL, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_ENT,                    KC_PGDN,
+    KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT,          KC_UP,
+    KC_LCTL,          KC_LALT,          KC_SPC,  MO(1),            KC_SPC,           KC_RALT,                   KC_LEFT, KC_DOWN, KC_RGHT
+  ),
+
+  [1] = LAYOUT(
+    KC_SLEP, KC_F13,  KC_F14,  KC_F15,  KC_F16,  KC_F17,  KC_F18,  KC_F19,  KC_F20,  KC_F21,  KC_F22,  KC_F23,  KC_F24,           KC_PSCR, KC_VOLU,
+    _______, 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_INS,  BL_STEP,
+    _______, _______, _______, _______, _______, _______, KC_HOME, KC_PGDN, KC_PGUP, KC_END,  _______, _______, _______, KC_DEL,           KC_MUTE,
+    KC_LGUI, _______, _______, _______, _______, _______, KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT, _______, _______, KC_MPLY,                   KC_VOLD,
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,          KC_MPLY,
+    _______,          _______,          _______, _______,          _______,          _______,                   KC_MPRV, KC_MSTP, KC_MNXT
+  ),
+
+  [2] = LAYOUT(
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,          _______, _______,
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,          _______,
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,                   _______,
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,          _______,
+    _______,          _______,          _______, _______,          _______,          _______,                   _______, _______, _______
+  ),
+
+  [3] = LAYOUT(
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,          _______, _______,
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,          _______,
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,                   _______,
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,          _______,
+    _______,          _______,          _______, _______,          _______,          _______,                   _______, _______, _______
+  )
+};
--- a/keyboards/adelheid/keymaps/via/rules.mk
+++ b/keyboards/adelheid/keymaps/via/rules.mk
@ -0,0 +1,2 @@
+VIA_ENABLE = yes
+LTO_ENABLE = yes
--- a/Show More
+++ b/Show More