[Core] Convert Dynamic Macro to a Core Feature (#5948)

* Convert Dynamic Macro to a Core Feature

This imports the code from Dynamic Macro into the core code, and handles it, as such.

This deprecates the old method but does not remove it, for legacy support. This way, no existing user files need to be touched.

Additionally, this reorganizes the documentation to better reflect the changes.

Also, it adds user hooks to the feature so users can customize the existing functionality.

Based heavily on and closes #2976

* Apply suggestions from code review

Co-Authored-By: fauxpark <fauxpark@gmail.com>
Co-Authored-By: noroadsleft <18669334+noroadsleft@users.noreply.github.com>

* Cleanup based on feedback

* Add short-form keycodes and document them

- add short-form keycodes to quantum/quantum_keycodes.h
- document the new aliases in docs/feature_dynamic_macros.md

* Add Dynamic Macros section and keycodes to docs/keycodes.md

* Make anti-nesting optional

* Add documentation for DYNAMIC_MACRO_NO_NESTING option

* Fix Merge artifacts

* Fix formatting typo in docs

Co-Authored-By: James Young <18669334+noroadsleft@users.noreply.github.com>

* Remove DYNAMIC_MACRO_RANGE as it's not needed

* Fix includes and layer var type

.travis.yml

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

bin/qmk

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

common_features.mk

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

docs/_langs.md

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

docs/coding_conventions_python.md

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

docs/config_options.md

@@ -348,7 +348,8 @@ Use these to enable or disable building certain features. The more you have enab
 * `NO_USB_STARTUP_CHECK`
   * Disables usb suspend check after keyboard startup. Usually the keyboard waits for the host to wake it up before any tasks are performed. This is useful for split keyboards as one half will not get a wakeup call but must send commands to the master.
 * `LINK_TIME_OPTIMIZATION_ENABLE`
-  = Enables Link Time Optimization (`LTO`) when compiling the keyboard.  This makes the process take longer, but can significantly reduce the compiled size (and since the firmware is small, the added time is not noticable).  However, this will automatically disable the old Macros and Functions features automatically, as these break when `LTO` is enabled.  It does this by automatically defining `NO_ACTION_MACRO` and `NO_ACTION_FUNCTION`
+  * Enables Link Time Optimization (`LTO`) when compiling the keyboard.  This makes the process take longer, but can significantly reduce the compiled size (and since the firmware is small, the added time is not noticeable).  However, this will automatically disable the old Macros and Functions features automatically, as these break when `LTO` is enabled.  It does this by automatically defining `NO_ACTION_MACRO` and `NO_ACTION_FUNCTION`
+  * Alternatively, you can use `LTO_ENABLE` instead of `LINK_TIME_OPTIMIZATION_ENABLE`. 
 
 ## USB Endpoint Limitations
 

docs/es/README.md

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

docs/es/_summary.md

@@ -0,0 +1,121 @@
+* [Guía completa para novatos](newbs.md)
+  * [Empezando](newbs_getting_started.md)
+  * [Construyendo tu primer firmare](newbs_building_firmware.md)
+  * [Flasheando el firmware](newbs_flashing.md)
+  * [Testeando y depurando ](newbs_testing_debugging.md)
+  * [Mejores práticas](newbs_best_practices.md)
+  * [Recursos de aprendizaje](newbs_learn_more_resources.md)
+
+* [QMK Basics](README.md)
+  * [Introducción a QMK](getting_started_introduction.md)
+  * [QMK CLI](cli.md)
+  * [Configuración de QMK CLI](cli_configuration.md)
+  * [Contribuyendo a QMK](contributing.md)
+  * [Cómo usar Github](getting_started_github.md)
+  * [Obtener ayuda](getting_started_getting_help.md)
+
+* [Cambios incompatibles](breaking_changes.md)
+  * [30 Ago 2019](ChangeLog/20190830.md)
+
+* [Preguntas frecuentes](faq.md)
+  * [General](faq_general.md)
+  * [Construir/Compilar QMK](faq_build.md)
+  * [Depurando/Encontrando problemas en QMK](faq_debug.md)
+  * [Keymap](faq_keymap.md)
+  * [Instalación de drivers con Zadig](driver_installation_zadig.md)
+
+* Guías detalladas
+  * [Instalar herramientas construcción](getting_started_build_tools.md)
+  * [Guía Vagrant](getting_started_vagrant.md)
+  * [Instrucciones de Construcción/Compilado](getting_started_make_guide.md)
+  * [Flasheando Firmware](flashing.md)
+  * [Personalizando funcionalidad](custom_quantum_functions.md)
+  * [Visión general del Keymap](keymap.md)
+
+* [Hardware](hardware.md)
+  * [Procesadores AVR](hardware_avr.md)
+  * [Drivers](hardware_drivers.md)
+
+* Referencia
+  * [Pautas de teclados](hardware_keyboard_guidelines.md)
+  * [Opciones de configuración](config_options.md)
+  * [Keycodes](keycodes.md)
+  * [Convenciones de código - C](coding_conventions_c.md)
+  * [Convenciones de código - Python](coding_conventions_python.md)
+  * [Mejores prácticas de documentación](documentation_best_practices.md)
+  * [Plantillas de documentación](documentation_templates.md)
+  * [Glosario](reference_glossary.md)
+  * [Tests unitarios](unit_testing.md)
+  * [Funciones útiles](ref_functions.md)
+  * [Sporte configurador](reference_configurator_support.md)
+  * [Formato info.json](reference_info_json.md)
+  * [Desarrollo Python CLI](cli_development.md)
+
+* [Características](features.md)
+  * [Keycodes Básicos](keycodes_basic.md)
+  * [Teclas US ANSI Shifted](keycodes_us_ansi_shifted.md)
+  * [Keycodes Quantum](quantum_keycodes.md)
+  * [Keycodes Avanzados](feature_advanced_keycodes.md)
+  * [Audio](feature_audio.md)
+  * [Auto Shift](feature_auto_shift.md)
+  * [Retroiluminación](feature_backlight.md)
+  * [Bluetooth](feature_bluetooth.md)
+  * [Bootmagic](feature_bootmagic.md)
+  * [Combos](feature_combo.md)
+  * [Comando](feature_command.md)
+  * [API Debounce](feature_debounce_type.md)
+  * [Switch DIP](feature_dip_switch.md)
+  * [Macros Dinámicas](feature_dynamic_macros.md)
+  * [Encoders](feature_encoders.md)
+  * [Grave Escape](feature_grave_esc.md)
+  * [Feedback Háptico](feature_haptic_feedback.md)
+  * [Controlador LCD HD44780](feature_hd44780.md)
+  * [Key Lock](feature_key_lock.md)
+  * [Layouts](feature_layouts.md)
+  * [Tecla Leader](feature_leader_key.md)
+  * [Matriz LED](feature_led_matrix.md)
+  * [Macros](feature_macros.md)
+  * [Teclas del ratón](feature_mouse_keys.md)
+  * [Driver OLED](feature_oled_driver.md)
+  * [Teclas One Shot](feature_advanced_keycodes.md#one-shot-keys)
+  * [Dispositivo de apuntado](feature_pointing_device.md)
+  * [Ratón PS/2](feature_ps2_mouse.md)
+  * [Iluminación RGB](feature_rgblight.md)
+  * [Matriz RGB](feature_rgb_matrix.md)
+  * [Cadete espacial](feature_space_cadet.md)
+  * [Teclado dividido](feature_split_keyboard.md)
+  * [Stenografía](feature_stenography.md)
+  * [Swap Hands](feature_swap_hands.md)
+  * [Tap Dance](feature_tap_dance.md)
+  * [Terminal](feature_terminal.md)
+  * [Impresora Térmica](feature_thermal_printer.md)
+  * [Unicode](feature_unicode.md)
+  * [Userspace](feature_userspace.md)
+  * [Velocikey](feature_velocikey.md)
+
+* Para Makers y Modders
+  * [Guía de cableado a mano](hand_wire.md)
+  * [Guía de flasheado de ISP](isp_flashing_guide.md)
+  * [Guía de depuración de ARM](arm_debugging.md)
+  * [Driver I2C](i2c_driver.md)
+  * [Controles GPIO](internals_gpio_control.md)
+  * [Conversión Proton C](proton_c_conversion.md)
+
+* Para entender en profundidad
+  * [Cómo funcionan los teclados](how_keyboards_work.md)
+  * [Entendiendo QMK](understanding_qmk.md)
+
+* Otros temas
+  * [Usando Eclipse con QMK](other_eclipse.md)
+  * [Usando VSCode con QMK](other_vscode.md)
+  * [Soporte](support.md)
+  * [Cómo añadir traducciones](translating.md)
+
+* QMK Internals (En progreso)
+  * [Defines](internals_defines.md)
+  * [Input Callback Reg](internals_input_callback_reg.md)
+  * [Dispositivo Midi](internals_midi_device.md)
+  * [Proceso de configuración de un dispositivo Midi](internals_midi_device_setup_process.md)
+  * [Utilidad Midi](internals_midi_util.md)
+  * [Funciones Send](internals_send_functions.md)
+  * [Herramientas Sysex](internals_sysex_tools.md)

docs/es/becoming_a_qmk_collaborator.md

@@ -0,0 +1,9 @@
+# Llegar a ser un colaborador QMK
+
+Un colaborador QMK es un maker o diseñador de teclados que tiene interés en ayudar a QMK a crecer y mantener sus teclado(s), y alentar a los usuarios y clientes a presentar herramientas, ideas, y keymaps. Siempre procuramos agregar más teclados y colaboradores, pero pedimos que cumplan los siguientes requisitos:
+
+* **Tener un PCB disponible a la venta.** Desafortunadamente, hay demasiada variación y complicaciones con teclados cableados a mano.
+* **Realizar el mantenimiento de tu teclado en QMK.** Este podría requirir un setup inicial para hacer que tu teclado funcione, pero también podría incluir adaptarse a cambios hecho al base de QMK que podrían descomponer o rendir código superfluo.
+* **Aprobar e incorporar pull requests de keymaps para tu teclado.** Nos gusta alentar a los usuarios a contribuir sus keymaps para que otros los vean y los puedan usar para crear sus propios.
+
+Si sientes que cumples los requisitos, ¡mándanos un email a hello@qmk.fm con una introducción y algunos enlaces para tu teclado!

docs/es/hardware.md

@@ -0,0 +1,8 @@
+# Hardware
+
+QMK es compatible con una variedad de hardware. Si tu procesador puede ser dirigido por [LUFA](http://www.fourwalledcubicle.com/LUFA.php) o [ChibiOS](http://www.chibios.com), probablemente puedes hacer que QMK se ejecute en él. Esta sección explora cómo hacer que QMK se ejecute y se comunique con hardware de todo tipo.
+
+* [Pautas de teclados](hardware_keyboard_guidelines.md)
+* [Procesadores AVR](hardware_avr.md)
+* Procesadores ARM (TBD)
+* [Drivers](hardware_drivers.md)

docs/es/hardware_avr.md

@@ -0,0 +1,181 @@
+# Teclados con Procesadores AVR
+
+Esta página describe el soporte para procesadores AVR en QMK. Los procesadores AVR incluyen el atmega32u4, atmega32u2, at90usb1286, y otros procesadores de la Corporación Atmel. Los procesadores AVR son MCUs de 8-bit que son diseñados para ser fáciles de trabajar. Los procesadores AVR más comunes en los teclados tienen USB y un montón de GPIO para permitir grandes matrices de teclado. Son los MCUs más populares para el uso en los teclados hoy en día.
+
+Si aún no lo has hecho, debes leer las [Pautas de teclados](hardware_keyboard_guidelines.md) para tener una idea de cómo los teclados encajan en QMK.
+
+## Añadir tu Teclado AVR a QMK
+
+QMK tiene varias características para simplificar el trabajo con teclados AVR. Para la mayoría de los teclados no tienes que escribir ni una sola línea de código. Para empezar, ejecuta el archivo `util/new_keyboard.sh`:
+
+```
+$ ./util/new_keyboard.sh
+Generating a new QMK keyboard directory
+
+Keyboard Name: mycoolkb
+Keyboard Type [avr]: 
+Your Name [John Smith]: 
+
+Copying base template files... done
+Copying avr template files... done
+Renaming keyboard files... done
+Replacing %KEYBOARD% with mycoolkb... done
+Replacing %YOUR_NAME% with John Smith... done
+
+Created a new keyboard called mycoolkb.
+
+To start working on things, cd into keyboards/mycoolkb,
+or open the directory in your favourite text editor.
+```
+
+Esto creará todos los archivos necesarios para tu nuevo teclado, y rellenará la configuración con valores predeterminados. Ahora sólo tienes que personalizarlo para tu teclado. 
+
+## `readme.md`
+
+Aquí es donde describirás tu teclado. Por favor sigue la [Plantilla del readme de teclados](documentation_templates.md#keyboard-readmemd-template) al escribir tu `readme.md`. Te animamos a colocar una imagen en la parte superior de tu `readme.md`. Por favor, utiliza un servicio externo como [Imgur](http://imgur.com) para alojar las imágenes.
+
+## `<keyboard>.c`
+
+Aquí es donde pondrás toda la lógica personalizada para tu teclado. Muchos teclados no necesitan nada aquí. Puedes aprender más sobre cómo escribir lógica personalizada en [Funciones Quantum Personalizadas](custom_quantum_functions.md).
+
+## `<keyboard>.h`
+
+Este es el archivo en el que defines tu(s) [Macro(s) de Layout](feature_layouts.md). Por lo menos deberías tener un `#define LAYOUT` para tu teclado que se ve algo así:
+
+```c
+#define LAYOUT(          \
+      k00, k01, k02,     \
+      k10,   k11         \
+) {                      \
+    { k00, k01,   k02 }, \
+    { k10, KC_NO, k11 }, \
+}
+```
+
+La primera mitad de la macro pre-procesador `LAYOUT` define la disposición física de las llaves. La segunda mitad de la macro define la matriz a la que están conectados los interruptores. Esto te permite tener una disposición física de las llaves que difiere de la matriz de cableado.
+
+Cada una de las variables `k__` tiene que ser única, y normalmente sigue el formato `k<row><col>`.
+
+La matriz física (la segunda mitad) debe tener un número de filas igualando `MATRIX_ROWS`, y cada fila debe tener exactamente `MATRIX_COLS` elementos. Si no tienes tantas teclas físicas puedes usar `KC_NO` para rellenar los espacios en blanco.
+
+## `config.h`
+
+El archivo `config.h` es donde configuras el hardware y el conjunto de características para tu teclado. Hay un montón de opciones que se pueden colocar en ese archivo, demasiadas para listar allí. Para obtener una visión de conjunto completa de las opciones disponibles consulta la página de [Opciones de Configuración](config_options.md).
+
+### Configuración de hardware
+
+
+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.
+
+```c
+#define VENDOR_ID       0xFEED
+#define PRODUCT_ID      0x6060
+#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.
+
+### Configuración de la matriz del teclado
+
+La siguiente sección del archivo `config.h` trata de la matriz de tu teclado. Lo primero que debes establecer es el tamaño de la matriz. Esto es generalmente, pero no siempre, el mismo número de filas y columnas como la disposición física de las teclas.
+
+```c
+#define MATRIX_ROWS 2
+#define MATRIX_COLS 3
+```
+
+Una vez que hayas definido el tamaño de tu matriz, necesitas definir qué pines en tu MCU están conectados a filas y columnas. Para hacerlo simplemente especifica los nombres de esos pines:
+
+```c
+#define MATRIX_ROW_PINS { D0, D5 }
+#define MATRIX_COL_PINS { F1, F0, B0 }
+#define UNUSED_PINS
+```
+
+El número de entradas debe ser el mismo que el número que asignaste a `MATRIX_ROWS`, y del mismo modo para `MATRIX_COL_PINS` y `MATRIX_COLS`. No tienes que especificar `UNUSED_PINS`, pero puedes si deseas documentar qué pines están abiertos.
+
+Finalmente, puedes especificar la dirección en la que apuntan tus diodos. Esto puede ser `COL2ROW` o `ROW2COL`.
+
+```c
+#define DIODE_DIRECTION COL2ROW
+```
+
+#### Matriz de patas directas
+Para configurar un teclado en el que cada interruptor está conectado a un pin y tierra separados en lugar de compartir los pines de fila y columna, usa `DIRECT_PINS`. La asignación define los pines de cada interruptor en filas y columnas, de izquierda a derecha. Debe ajustarse a los tamaños dentro de `MATRIX_ROWS` y `MATRIX_COLS`. Usa `NO_PIN` para rellenar espacios en blanco. Sobreescribe el comportamiento de `DIODE_DIRECTION`, `MATRIX_ROW_PINS` y `MATRIX_COL_PINS`.
+
+```c
+// #define MATRIX_ROW_PINS { D0, D5 }
+// #define MATRIX_COL_PINS { F1, F0, B0 }
+#define DIRECT_PINS { \
+    { F1, E6, B0, B2, B3 }, \
+    { F5, F0, B1, B7, D2 }, \
+    { F6, F7, C7, D5, D3 }, \
+    { B5, C6, B6, NO_PIN, NO_PIN } \
+}
+#define UNUSED_PINS
+
+/* COL2ROW, ROW2COL */
+//#define DIODE_DIRECTION
+```
+
+### Configuración de retroiluminación
+
+QMK soporta retroiluminación en la mayoría de los pines GPIO. Algunos de ellos pueden ser manejados por el MCU en hardware. Para más detalles, consulta la [Documentación de Retroiluminación](feature_backlight.md).
+
+```c
+#define BACKLIGHT_PIN B7
+#define BACKLIGHT_LEVELS 3
+#define BACKLIGHT_BREATHING
+#define BREATHING_PERIOD 6
+```
+
+### Otras opciones de configuración
+
+Hay un montón de características que se pueden configurar o ajustar en `config.h`. Debes consultar la página de [Opciones de Configuración](config_options.md) para más detalles.
+
+## `rules.mk`
+
+Usa el archivo `rules.mk` para decirle a QMK qué archivos construir y qué características habilitar. Si estás construyendo sobre un atmega32u4 deberías poder dejar mayormente los valores predeterminados. Si estás usando otro MCU es posible que tengas que ajustar algunos parámetros.
+
+### Opciones MCU
+
+Estas opciones le indican al sistema de compilación para qué CPU construir. Ten mucho cuidado si cambias cualquiera de estos ajustes. Puedes inutilizar tu teclado.
+
+```make
+MCU = atmega32u4
+F_CPU = 16000000
+ARCH = AVR8
+F_USB = $(F_CPU)
+OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+```
+
+### Gestores de arranque
+
+El gestor de arranque es una sección especial de tu MCU que te permite actualizar el código almacenado en el MCU. Piensa en ello como una partición de rescate para tu teclado.
+
+#### Ejemplo de gestor de arranque
+
+```make
+BOOTLOADER = halfkay
+```
+
+#### Ejemplo de cargador DFU Atmel
+
+```make
+BOOTLOADER = atmel-dfu
+```
+
+#### Ejemplo de gestor de arranque Pro Micro
+
+```make
+BOOTLOADER = caterina
+```
+
+### Opciones de construcción
+
+Hay un serie de características que se pueden activar o desactivar en `rules.mk`. Consulta la página de [Opciones de Configuración](config_options.md#feature-options) para obtener una lista detallada y una descripción.

docs/es/hardware_drivers.md

@@ -0,0 +1,36 @@
+# Controladores de hardware QMK
+
+QMK se utiliza en un montón de hardware diferente. Mientras que el soporte para los MCUs y las configuraciones de matriz más comunes está integrado, hay una serie de controladores que se pueden añadir para soportar hardware adicional al teclado. Los ejemplos incluyen ratones y otros dispositivos de apuntamiento, extensores de i/o para teclados divididos, modúlos Bluetooth, y pantallas LCD, OLED y TFT.
+
+<!-- FIXME: Esto debe hablar de cómo se integran los controladores en QMK y cómo puedes añadir su propio controlador.
+
+# Descripción del sistema de controladores
+
+-->
+
+# Controladores disponibles
+
+## ProMicro (Solo AVR)
+
+Soporte para direccionar pines en el ProMicro por su nombre Arduino en lugar de su nombre AVR. Esto necesita ser mejor documentado. Si estás tratando de hacer esto y leer el código no ayuda por favor [abre una issue](https://github.com/qmk/qmk_firmware/issues/new) y podemos ayudarte por el proceso.
+
+## Controlador OLED SSD1306
+
+Soporte para pantallas OLED basadas en SSD1306. Para obtener más información consulta la página de [Característica de Controlador OLED](feature_oled_driver.md).
+
+## uGFX
+
+Puedes hacer uso de uGFX dentro de QMK para manejar LCDs de caracteres y gráficos, matrices de LED, OLED, TFT, y otras tecnologías de visualización. Esto necesita ser mejor documentado. Si estás tratando de hacer esto y leer el código no ayuda por favor [abre una issue](https://github.com/qmk/qmk_firmware/issues/new) y podemos ayudarte por el proceso.
+
+## WS2812 (Solo AVR)
+
+Soporte para LEDs WS2811/WS2812{a,b,c}. Para obtener más información consulta la página de [Luz RGB](feature_rgblight.md).
+
+## IS31FL3731
+
+Soporte para hasta 2 controladores. Cada controlador implementa 2 matrices charlieplex para direccionar LEDs individualmente usando I2C. Esto permite hasta 144 LEDs del mismo color o 32 LEDs RGB. Para obtener más información sobre cómo configurar el controlador, consulta la página de [Matriz RGB](feature_rgb_matrix.md).
+
+## IS31FL3733
+
+Soporte para hasta un solo controlador con espacio para expansión. Cada controlador puede controlar 192 LEDs individuales o 64 LEDs RGB. Para obtener más información sobre cómo configurar el controlador, consulta la página de [Matriz RGB](feature_rgb_matrix.md).
+

docs/es/hardware_keyboard_guidelines.md

@@ -0,0 +1,149 @@
+# Pautas del teclado QMK
+
+Desde sus inicios, QMK ha crecido a pasos agigantados gracias a personas como tú que contribuyes a la creación y mantenimiento de nuestros teclados comunitarios. A medida que hemos crecido hemos descubierto algunos patrones que funcionan bien, y pedimos que te ajustes a ellos para que sea más fácil para que otras personas se beneficien de tu duro trabajo.
+
+
+## Nombrar tu Teclado/Proyecto
+
+Todos los nombres de teclado están en minúsculas, consistiendo sólo de letras, números y guiones bajos (`_`). Los nombres no pueden comenzar con un guión bajo. La barra de desplazamiento (`/`) se utiliza como un carácter de separación de subcarpetas.
+
+Los nombres `test`, `keyboard`, y `all` están reservados para las órdenes de make y no pueden ser usados como un nombre de teclado o subcarpeta.
+
+Ejemplos Válidos:
+
+* `412_64`
+* `chimera_ortho`
+* `clueboard/66/rev3`
+* `planck`
+* `v60_type_r`
+
+## Subcarpetas
+
+QMK utiliza subcarpetas tanto para organización como para compartir código entre las revisiones del mismo teclado. Puedes anidar carpetas hasta 4 niveles de profundidad:
+
+    qmk_firmware/keyboards/top_folder/sub_1/sub_2/sub_3/sub_4
+
+Si una subcarpeta tiene un archivo `rules.mk` será considerado un teclado compilable. Estará disponible en el configurador de QMK y se probará con `make all`. Si estás utilizando una carpeta para organizar varios teclados del mismo fabricante no debes tener un archivo `rules.mk`.
+
+Ejemplo:
+
+Clueboard utiliza subcarpetas para ambos propósitos: organización y revisiones de teclado.
+
+* [`qmk_firmware`](https://github.com/qmk/qmk_firmware/tree/master)
+  * [`keyboards`](https://github.com/qmk/qmk_firmware/tree/master/keyboards)
+    * [`clueboard`](https://github.com/qmk/qmk_firmware/tree/master/keyboards/clueboard)  ← This is the organization folder, there's no `rules.mk` file
+      * [`60`](https://github.com/qmk/qmk_firmware/tree/master/keyboards/clueboard/60)  ← This is a compilable keyboard, it has a `rules.mk` file
+      * [`66`](https://github.com/qmk/qmk_firmware/tree/master/keyboards/clueboard/66) ← This is also compilable- it uses `DEFAULT_FOLDER` to specify `rev3` as the default revision
+        * [`rev1`](https://github.com/qmk/qmk_firmware/tree/master/keyboards/clueboard/66/rev1) ← compilable: `make clueboard/66/rev1`
+        * [`rev2`](https://github.com/qmk/qmk_firmware/tree/master/keyboards/clueboard/66/rev2) ← compilable: `make clueboard/66/rev2`
+        * [`rev3`](https://github.com/qmk/qmk_firmware/tree/master/keyboards/clueboard/66/rev3) ← compilable: `make clueboard/66/rev3` or `make clueboard/66`
+
+## Estructura de carpetas de teclado
+
+Su teclado debe estar ubicado en `qmk_firm cuidada/keyboards/` y el nombre de la carpeta debe ser el nombre de su teclado como se describe en la sección anterior. Dentro de esta carpeta debe haber varios archivos:
+
+* `readme.md`
+* `info.json`
+* `config.h`
+* `rules.mk`
+* `<keyboard_name>.c`
+* `<keyboard_name>.h`
+
+### `readme.md`
+
+Todos los proyectos necesitan tener un archivo `readme.md` que explica lo que es el teclado, quién lo hizo y dónde está disponible. Si es aplicable, también debe contener enlaces a más información, como el sitio web del fabricante. Por favor, sigue la [plantilla publicada](documentation_templates.md#keyboard-readmemd-template).
+
+### `info.json`
+
+Este archivo es utilizado por la [API de QMK](https://github.com/qmk/qmk_api). Contiene la información que [configurador de QMK](https://config.qmk.fm/) necesita mostrar en una representación de su teclado. También puede establecer metadatos aquí. Para más información, consulta la [página de referencia](reference_info_json.md).
+
+### `config.h`
+
+Todos los proyectos necesitan tener un archivo `config.h` que establece cosas como el tamaño de la matriz, nombre del producto, USB VID/PID, descripción y otros ajustes. En general, usa este archivo para establecer la información esencial y los valores predeterminados para tu teclado que siempre funcionarán.
+
+### `rules.mk`
+
+La presencia de este archivo indica que la carpeta es un destino de teclado y se puede utilizar en las órdenes `make`. Aquí es donde estableces el entorno de compilación para tu teclado y configuras el conjunto predeterminado de características.
+
+### `<keyboard_name.c>`
+
+Aquí es donde escribirás código personalizado para tu teclado. Típicamente escribirás código para inicializar e interactuar con el hardware de tu teclado. Si tu teclado se compone de sólo una matriz de teclas sin LEDs, altavoces u otro hardware auxiliar este archivo puede estar en blanco.
+
+Las funciones siguientes se definen típicamente en este archivo:
+
+* `void matrix_init_kb(void)`
+* `void matrix_scan_kb(void)`
+* `bool process_record_kb(uint16_t keycode, keyrecord_t *record)`
+* `void led_set_kb(uint8_t usb_led)`
+
+### `<keyboard_name.h>`
+
+Este archivo se utiliza para definir la matriz para tu teclado. Debes definir al menos un macro de C que traduce una serie en una matriz que representa la matriz de interruptor físico para tu teclado. Si es posible construir tu teclado con múltiples diseños debes definir macros adicionales.
+
+Si solo tienes un diseño debes llamar a esta macro `LAYOUT`.
+
+Al definir diseños múltiples debes tener un diseño base, llamado `LAYOUT_all`, que soporte todas las posibles posiciones de switch en tu matriz, incluso si ese diseño es imposible de construir físicamente. Esta es la macro que deberías usar en tu keymap `predeterminado`. Debes tener keymaps adicionales llamados `default_ término layout>` que usen tus otras macros de diseño. Esto hará que sea más fácil para las personas utilizar los diseños que defines.
+
+Los nombres de las macros de diseño son completamente minúsculas, excepto por la palabra `LAYOUT` en el frente.
+
+Por ejemplo, si tienes un PCB de 60% que soporta ANSI e ISO podría definir los siguientes diseños y keymaps:
+
+| Nombre de diseño | Nombre de keymap | Descripción |
+|-------------|-------------|-------------|
+| LAYOUT_all | default | Un diseño que soporta tanto ISO como ANSI |
+| LAYOUT_ansi | default_ansi | Un diseño ANSI |
+| LAYOUT_iso | default_iso | Un diseño ISO |
+
+## Archivos de Imagen/Hardware
+
+En un esfuerzo por mantener el tamaño de repo abajo ya no estamos aceptando archivos binarios de cualquier formato, con pocas excepciones. Alojarlos en otro lugar (por ejemplo <https://imgur.com>) y enlazarlos en el `readme.md` es preferible.
+
+Para archivos de hardware (tales como placas, casos, pcb) puedes contribuir a [qmk.fm repo](https://github.com/qmk/qmk.fm) y estarán disponibles en [qmk.fm](http://qmk.fm). Archivos descargables se almacenan en `/<teclado>/` (nombre sigue el mismo formato que el anterior), se sirven en `http://qmk.fm/<teclado>/`, y se generan páginas de `/_pages/<teclado>/` que se sirven en la misma ubicación (Los archivos .md se generan en archivos .html mediante Jekyll). Echa un vistazo a la carpeta `lets_split` para ver un ejemplo.
+
+## Predeterminados de teclado
+
+Dada la cantidad de funcionalidad que expone QMK, es muy fácil confundir a los nuevos usuarios. Al armar el firmware predeterminado para tu teclado, te recomendamos limitar tus funciones y opciones habilitadas al conjunto mínimo necesario para soportar tu hardware. A continuación se formulan recomendaciones sobre características específicas.
+
+### Bootmagic y Command
+
+[Bootmagic](feature_bootmagic.md) and [Command](feature_command.md) son dos características relacionadas que permiten a un usuario controlar su teclado de manera no obvia. Te recomendamos que piense largo y tendido acerca de si vas a habilitar cualquiera de las características, y cómo vas a exponer esta funcionalidad. Tengas en cuenta que los usuarios que quieren esta funcionalidad puede habilitarla en sus keymaps personales sin afectar a todos los usuarios novatos que pueden estar usando tu teclado como su primera tarjeta programable.
+
+De lejos el problema más común con el que se encuentran los nuevos usuarios es la activación accidental de Bootmagic mientras están conectando su teclado. Están sosteniendo el teclado por la parte inferior, presionando sin saberlo en alt y barra espaciadora, y luego se dan cuenta de que estas teclas han sido intercambiadas en ellos. Recomendamos dejar esta característica deshabilitada de forma predeterminada, pero si la activas consideres establecer la opción `BOOTMAGIC_KEY_SALT` a una tecla que es difícil de presionar al conectar el teclado.
+
+Si tu teclado no tiene 2 teclas de cambio debes proporcionar un predeterminado de trabajo para `IS_COMMAND`, incluso cuando haya definido `COMMAND_ENABLE = no`. Esto dará a sus usuarios un valor predeterminado para ajustarse a si lo hacen enable Command.
+
+## Programación de teclado personalizado
+
+Como se documenta en [Funcionalidad de Adaptación](custom_quantum_functions.md) puedes definir funciones personalizadas para tu teclado. Por favor, tengas en cuenta que sus usuarios pueden querer personalizar ese comportamiento así, y hacer que sea posible para que puedan hacer eso. Si está proporcionando una función personalizada, por ejemplo `process_record_kb()`, asegúrese de que su función también llame a la versión` `_user()` de la llamada. También debes tener en cuenta el valor de retorno de la versión `_user()`, y ejecutar sólo tu código personalizado si el usuario devuelve `true`.
+
+## Proyectos Sin Producción/Conectados A Mano
+
+Estamos encantados de aceptar cualquier proyecto que utilice QMK, incluidos los prototipos y los cableados de mano, pero tenemos una carpeta `/keyboards/handwired/` separada para ellos, por lo que la carpeta `/keyboards/` principal no se llena. Si un proyecto prototipo se convierte en un proyecto de producción en algún momento en el futuro, ¡estaremos encantados de moverlo a la carpeta `/keyboards/` principal!
+
+## Advertencias como errores
+
+Al desarrollar su teclado, tengas en cuenta que todas las advertencias serán tratadas como errores - estas pequeñas advertencias pueden acumularse y causar errores más grandes en el camino (y pierdan es generalmente una mala práctica).
+
+## Derechos de autor
+
+Si estás adaptando la configuración de tu teclado de otro proyecto, pero no utilizando el mismo código, asegúrese de actualizar la cabecera de derechos de autor en la parte superior de los archivos para mostrar tu nombre, en este formato:
+
+    Copyright 2017 Tu nombre <tu@email.com>
+
+Si estás modificando el código de otra persona y sólo ha hecho cambios triviales debes dejar su nombre en la declaración de derechos de autor. Si has hecho un trabajo significativo en el archivo debe agregar tu nombre a la de ellos, así:
+
+    Copyright 2017 Su nombre <original_author@ejemplo.com> Tu nombre <tu@ejemplo.com>
+
+El año debe ser el primer año en que se crea el archivo. Si el trabajo se hizo a ese archivo en años posteriores puedes reflejar que mediante la adición del segundo año a la primera, como así:
+
+    Copyright 2015-2017 Tu nombre <tu@ejemplo.com>
+
+## Licencia
+
+El núcleo de QMC está licenciado bajo la [GNU General Public License](https://www.gnu.org/licenses/licenses.en.html). Si estás enviando binarios para los procesadores AVR puedes elegir cualquiera [GPLv2](https://www.gnu.org/licenses/old-licenses/gpl-2.0.html) o [GPLv3](https://www.gnu.org/licenses/gpl.html). Si estás enviando binarios para ARM procesadores debes elegir [GPL Versión 3](https://www.gnu.org/licenses/gpl.html) para cumplir con los [ChibiOS](http://www.chibios.org) licencia GPLv3.
+
+Si tu teclado hace uso de la [uGFX](https://gfx.io) características dentro de QMK debes cumplir con la [Licencia de uGFX](https://ugfx.io/license.html), que requiere una licencia comercial separada antes de vender un dispositivo que contiene uGFX.
+
+## Detalles técnicos
+
+Si estás buscando más información sobre cómo hacer que su teclado funcione con QMK, [echa un vistazo a la sección hardware](hardware.md)!

docs/es/newbs.md

@@ -0,0 +1,23 @@
+# La guía completa de QMK para novatos
+
+QMK es un poderoso firmware Open Source para tu teclado mecánico. Puedes utilizar QMK para personalizar tu teclado en maneras a la vez simples y potentes. Gente de todos los niveles de habilidad, desde completos novatos hasta expertos programadores, han utilizado con éxito QMK para personalizar sus teclados. Esta guía te ayudará a hacer lo mismo, sin importar tu nivel de habilidad.
+
+¿No estás seguro de si tu teclado puede ejecutar QMK? Si es un teclado mecánico construido por ti mismo probablemente puedas. Damos soporte a [gran número de placas de hobbistas](http://qmk.fm/keyboards/), e incluso si tu teclado actual no pudiera ejecutar QMK no deberías tener problemas encontrando uno que cumpliera tus necesidades.
+
+## Visión general
+
+Hay 7 secciones principales en esta guía:
+
+* [Empezando](newbs_getting_started.md)
+* [Construyendo tu primer firmware](newbs_building_firmware.md)
+* [Construyendo tu primer firmware usando la GUI](newbs_building_firmware_configurator.md)
+* [Flasheando el firmware](newbs_flashing.md)
+* [Testeando y depurando](newbs_testing_debugging.md)
+* [Mejores práticas](newbs_best_practices.md)
+* [Recursos de aprendizaje](newbs_learn_more_resources.md)
+
+Esta guía está enfocada en ayudar a alguien que nunca ha compilado software con anterioridad. Toma decisiones y hace recomendaciones teniendo en cuenta este punto de vista. Hay métodos alternativos para muchos de estos procedimientos, y soportamos la mayoría de esas alternativas. Si tienes alguna duda sobre cómo llevar a cabo una tarea nos puedes [preguntar para que te guiemos](getting_started_getting_help.md).
+
+## Recursos adicionales
+
+* [Blog de Básicos de Thomas Baart's QMK](https://thomasbaart.nl/category/mechanical-keyboards/firmware/qmk/qmk-basics/) – Un blog creado por un usuario que cubre lo básico sobre cómo usar el firmware QMK Firmware, visto desde la perspectiva de un usuario nuevo.

docs/es/newbs_best_practices.md

@@ -0,0 +1,159 @@
+# Mejores prácticas
+
+## O, "Cómo aprendí a dejar de preocuparme y amarle a Git."
+
+Este documento procura instruir a los novatos en las mejores prácticas para tener una experiencia más fácil en contribuir a QMK. Te guiaremos por el proceso de contribuir a QMK, explicando algunas maneras de hacerlo más fácilmente, y luego romperemos algunas cosas para enseñarte cómo arreglarlas.
+
+En este documento suponemos un par de cosas:
+
+1. Tienes una cuenta de Github, y has hecho un [fork del repo qmk_firmware](getting_started_github.md) en tu cuenta.
+2. Has [configurado tu entorno de desarrollo](newbs_getting_started.md?id=environment-setup).
+
+
+## La rama master de tu fork: Actualizar a menudo, nunca commit
+
+Se recomienda que para desarrollo con QMK, lo que sea que estés haciendo, mantener tu rama `master` actualizada, pero **nunca** commit en ella. Mejor, haz todos tus cambios en una rama de desarrollo y manda pull requests de tus ramas mientras programas.
+
+Para evitar los conflictos de merge — cuando dos o más usuarios han editado la misma parte de un archivo al mismo tiempo — mantén tu rama `master` actualizada, y empieza desarrollo nuevo creando una nueva rama.
+
+### Actualizando tu rama master
+
+Para mantener tu rama `master` actualizada, se recomienda agregar el repository ("repo") de Firmware QMK como un repo remoto en git. Para hacer esto, abre tu interfaz de línea de mandatos y ingresa:
+```
+git remote add upstream https://github.com/qmk/qmk_firmware.git
+```
+
+Para verificar que el repo ha sido agregado, ejecuta `git remote -v`, y lo siguiente debe aparecer:
+
+```
+$ git remote -v
+origin  https://github.com/<your_username>/qmk_firmware.git (fetch)
+origin  https://github.com/<your_username>/qmk_firmware.git (push)
+upstream        https://github.com/qmk/qmk_firmware.git (fetch)
+upstream        https://github.com/qmk/qmk_firmware.git (push)
+```
+
+Ya que has hecho esto, puedes buscar actualizaciones del repo ejecutando `git fetch upstream`. Esto busca las ramas y etiquetas &mdash; juntos conocidos como "refs" &mdash; del repo QMK, que ahora tiene el apodo `upstream`. Ahora podemos comparar los archivos en nuestro fork `origin` con los de QMK.
+
+Para actualizar la rama master de tu fork, ejecuta lo siguiente, pulsando Intro después de cada línea:
+
+```
+git checkout master
+git fetch upstream
+git pull upstream master
+git push origin master
+```
+
+Esto te coloca en tu rama master, busca los refs del repo de QMK, descarga la rama `master` actual a tu computadora, y después lo sube a tu fork.
+
+### Hacer cambios
+
+Para hacer cambios, crea una nueva rama ejecutando:
+
+```
+git checkout -b dev_branch
+git push --set-upstream origin dev_branch
+```
+
+Esto crea una nueva rama llamada `dev_branch`, te coloca en ella, y después guarda la nueva rama a tu fork. El parámetro `--set-upstream` le dice a git que use tu fork y la rama `dev_branch` cada vez que uses `git push` o `git pull` en esta rama. Solo necesitas usarlo la primera que que subes cambios; ya después, puedes usar `git push` o `git pull`, sin usar los demás parámetros.
+
+!> Con `git push`, puedes usar `-u` en vez de `--set-upstream` &mdash; `-u` es un alias de `--set-upstream`.
+
+Puedes nombrar tu rama casi cualquier cosa, pero se recomienda ponerle algo con relación a los cambios que vas a hacer.
+
+Por defecto `git checkout -b` se basará tu nueva rama en la rama en la cual estás actualmente. Puedes basar tu rama en otra rama existente agregando el nombre de la rama al comando:
+
+```
+git checkout -b dev_branch master
+```
+
+Ahora que tienes una rama development, abre tu editor de texto y haz los cambios que quieres. Se recomienda hacer varios commits pequeños a tu rama; de este modo cualquier cambio que causa problemas puede ser rastreado y deshecho si fuera necesario. Para hacer tus cambios, edita y guarda los archivos que necesitas actualizar, agrégalos al *staging area* de Git, y luego haz un commit a tu rama:
+
+```
+git add path/to/updated_file
+git commit -m "My commit message."
+```
+`git add` agrega los archivos que han sido cambiados al *staging area* de Git, lo cual es la "zona de preparación"de Git. Este contiene los cambios que vas a *commit* usando `git commit`, que guarda los cambios en el repo. Usa un mensaje de commit descriptivo para que puedas saber que ha cambiado fácilmente.
+
+!> Si has cambiado muchos archivos, pero todos los archivos son parte del mismo cambio, puedes usar `git add .` para agregar todos los archivos cambiados que están en tu directiro actual, en vez de agregar cada archivo manualmente.
+
+### Publicar tus cambios
+
+El útimo paso es subir tus cambios a tu fork. Para hacerlo, ejecuta `git push`. Ahora Git publicará el estado actual de `dev_branch` a tu fork.
+
+
+## Resolver los conflictos del merge
+
+A veces cuando el trabajo en una rama tarda mucho tiempo en completarse,  los cambios que han sido hechos por otros chocan con los cambios que has hecho en tu rama cuando abres un pull request. Esto se llama un *merge conflict*, y es algo que ocurre cuando varias personas editan las mismas partes de los mismos archivos.
+
+### Rebase tus cambios
+
+Un *rebase* es la manera de Git de tomar los cambios que se aplicaron en un punto, deshacerlos, y aplicar estos mismos cambios en otro punto. En el caso de un conflicto de merge, puedes hacer un rebase de tu rama para recoger los cambios que has hecho.
+
+Para empezar, ejecuta lo siguiente:
+
+```
+git fetch upstream
+git rev-list --left-right --count HEAD...upstream/master
+```
+
+El comando `git rev-list` ejecutado aquí muestra el número de commits que difieren entre la rama actual y la rama master de QMK. Ejecutamos `git fetch` primero para asegurarnos de que tenemos los refs que representan es estado actual del repo upstream. El output del comando `git rev-list` muestra dos números:
+
+```
+$ git rev-list --left-right --count HEAD...upstream/master
+7       35
+```
+
+El primer número representa el número de commits en la rama actual desde que fue creada, y el segundo número es el número de commits hecho a `upstream/master` desde que la rama actual fue creada, o sea los cambios que no están registrados en la rama actual.
+
+Ahora que sabemos el estado actual de la rama actual y el del repo upstream, podemos empezar una operación rebase:
+
+```
+git rebase upstream/master
+```
+Esto le dice a Git que deshaga los commits en la rama actual, y después los re-aplica en la rama master de QMK.
+
+```
+$ git rebase upstream/master
+First, rewinding head to replay your work on top of it...
+Applying: Commit #1
+Using index info to reconstruct a base tree...
+M       conflicting_file_1.txt
+Falling back to patching base and 3-way merge...
+Auto-merging conflicting_file_1.txt
+CONFLICT (content): Merge conflict in conflicting_file_1.txt
+error: Failed to merge in the changes.
+hint: Use 'git am --show-current-patch' to see the failed patch
+Patch failed at 0001 Commit #1
+
+Resolve all conflicts manually, mark them as resolved with
+"git add/rm <conflicted_files>", then run "git rebase --continue".
+You can instead skip this commit: run "git rebase --skip".
+To abort and get back to the state before "git rebase", run "git rebase --abort".
+```
+
+Esto nos dice que tenemos un conflicto de merge, y nos dice el nombre del archivo con el conflict. Abre el archivo en tu editor de texto, y en alguna parte del archivo verás algo así:
+
+```
+<<<<<<< HEAD
+<p>For help with any issues, email us at support@webhost.us.</p>
+=======
+<p>Need help? Email support@webhost.us.</p>
+>>>>>>> Commit #1
+```
+La línea `<<<<<<< HEAD` marca el principio de un conflicto de merge, y la línea `>>>>>>> Commit #1` marca el final, con las secciones de conflicto separadas por `=======`. La parte del lado `HEAD` is de la versión de QMK master del archivo, y la parte marcada con el mensaje de commit es de la rama actual.
+
+Ya que Git rastrea *cambios de archivos* en vez del contenido de los archivos directamente, si Git no puede encontrar el texto que estaba en el archivo antes del último commit, no sabrá cómo editar el archivo. El editar el archivo de nuevo resolverá este conflicto. Haz tus cambios, y guarda el archivo.
+
+```
+<p>Need help? Email support@webhost.us.</p>
+```
+
+Ahora ejecuta:
+
+```
+git add conflicting_file_1.txt
+git rebase --continue
+```
+
+Git registra los cambios al archivo con conflictos, y sigue aplicando los commits de nuestra rama hasta llegar al final.

docs/es/newbs_building_firmware.md

@@ -0,0 +1,81 @@
+# Construyendo tu primer firmware
+
+Ahora que has configurado tu entorno de construcción estas listo para empezar a construir firmwares personalizados. Para esta sección de la guía alternaremos entre 3 programas - tu gestor de ficheros, tu editor de texto , y tu ventana de terminal. Manten los 3 abiertos hasta que hayas acabado y estés contento con el firmware de tu teclado.
+
+Si has cerrado y reabierto la ventana de tu terminal después de seguir el primero paso de esta guía, no olvides hacer `cd qmk_firmware` para que tu terminal esté en el directorio correcto.
+
+## Navega a tu carpeta de keymaps 
+
+Comienza navegando a la carpeta `keymaps` correspondiente a tu teclado.
+
+?> Si estás en macOS o Windows hay comandos que puedes utilizar fácilmente para abrir la carpeta keymaps.
+
+?> macOS:
+
+    abre keyboards/<keyboard_folder>/keymaps
+
+?> Windows:
+
+    inicia .\\keyboards\\<keyboard_folder>\\keymaps
+
+## Crea una copia del keymap `default`
+
+Una vez que tengas la carpeta `keymaps` abierta querrás crear una copia de la carpeta `default`. Recomendamos encarecidamente que nombres la carpeta igual que tu nombre de usuario de GitHub, pero puedes utilizar el nombre que quieras siempre que contenga sólo letras en minúscula, números y el caracter de guión bajo.
+
+Para automatizar el proceso, también tienes la opción de ejecutar el script `new_keymap.sh`. 
+
+Navega a la carpeta `qmk_firmware/util` e introduce lo siguiente:
+
+```
+./new_keymap.sh <keyboard path> <username>
+```
+
+Por ejemplo, para un usuario llamado John, intentando hacer un keymap nuevo para el 1up60hse, tendría que teclear
+
+```
+./new_keymap.sh 1upkeyboards/1up60hse john
+```
+
+## Abre `keymap.c` con tu editor de texto favorito
+
+Abre tu `keymap.c`. Dentro de este fichero encontrarás la estructura que controla cómo se comporta tu teclado. En lo alto de `keymap.c` puede haber distintos defines y enums que hacen el keymap más fácil de leer. Continuando por abajo encontrarás una línea con este aspecto:
+
+    const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+Esta línea indica el comienzo del listado de Capas. Debajo encontrarás líneas que contienen o bien `LAYOUT` o `KEYMAP`, y estas líneas indican el comienzo de una capa. Debajo de esa línea está la lista de teclas que pertenecen a esa capa concreta.
+
+!> Cuando estés editando tu fichero de keymap ten cuidado con no añadir ni eliminar ninguna coma. Si lo haces el firmware dejará de compilar y puede no ser fácil averiguar dónde está la coma faltante o sobrante.
+
+## Personaliza el Layout a tu gusto
+
+Cómo completar esta paso depende enteramente de ti. Haz ese pequeño cambio que querías o rehaz completamente todo. Puedes eliminar capas si no las necesitas todas, o añadir nuevas hasta un total de 32. Comprueba la siguiente documentación para descubrir qué es lo que puedes definir aquí:
+
+* [Keycodes](keycodes.md)
+* [Características](features.md)
+* [Preguntas frecuentes](faq.md)
+
+?> Mientras estás descubriendo cómo funcionan los keymaps, haz pequeños cambios. Cambios mayores pueden hacer difícil la depuración de problemas que puedan aparecer.
+
+## Construye tu firmware
+
+Cuando los cambios a tu keymap están completos necesitarás construir el firmware. Para hacerlo vuelve a la ventana de tu terminal y ejecuta el siguiente comando:
+
+    make <my_keyboard>:<my_keymap>
+
+Por ejemplo, si tu keymap se llama "xyverz" y estás construyendo un keymap para un planck rev5, utilizarás el siguiente comando:
+
+    make planck/rev5:xyverz
+
+Mientras compila, recibirás un montón de información de salida en la pantalla informándote de qué ficheros están siendo compilados. Debería acabar con una información similar a esta:
+
+```
+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
+```
+
+## Flashea tu firmware
+
+Continua con [Flasheando el firmware](newbs_flashing.md) para aprender cómo escribir tu firmware nuevo en tu teclado.

docs/es/newbs_building_firmware_configurator.md

@@ -0,0 +1,105 @@
+# Configurador QMK
+
+El [Configurador QMK](https://config.qmk.fm) es un entorno gráfico online que genera ficheros hexadecimales de Firmware QMK.  
+
+?> **Por favor sigue estos pasos en orden.**
+
+Ve el [Video tutorial](https://youtu.be/tx54jkRC9ZY)
+
+El Configurador QMK functiona mejor con Chrome/Firefox. 
+
+
+!> **Ficheros de otras herramientas como KLE, o kbfirmware no serán compatibles con el Configurador QMK. No las cargues, no las importes. El configurador Configurador QMK es una herramienta DIFERENTE. **
+
+## Seleccionando tu teclado
+
+Haz click en el desplegable y selecciona el teclado para el que quieres crear el keymap. 
+
+?> Si tu teclado tiene varias versiones, asegúrate de que seleccionas la correcta.** 
+
+Lo diré otra vez porque es importante
+
+!> **ASEGÚRATE DE QUE SELECCIONAS LA VERSIÓN CORRECTA!**
+
+Si se ha anunciado que tu teclado funciona con QMK pero no está en la lista, es probable que un desarrollador no se haya encargado de él aún o que todavía no hemos tenido la oportunidad de incluirlo. Abre un issue en [qmk_firmware](https://github.com/qmk/qmk_firmware/issues) solicitando soportar ese teclado un particular, si no hay un [Pull Request](https://github.com/qmk/qmk_firmware/pulls?q=is%3Aopen+is%3Apr+label%3Akeyboard) activo para ello. Hay también teclados que funcionan con QMK que están en las cuentas de github de sus manufacturantes. Acuérdate de comprobar esto también. 
+
+## Eligiendo el layout de tu teclado
+
+Elige el layout que mejor represente el keymap que quieres crear. Algunos teclados no tienen suficientes layouts o layouts correctos definidos aún. Serán soportados en el futuro. 
+
+## Nombre del keymap
+
+Llama a este keymap como quieras. 
+
+?> Si estás teniendo problemas para compilar, puede merecer la pena probar un cambio de nombre, ya que puede que ya exista en el repositorio de QMK Firmware.
+
+## Creando Tu keymap
+
+La adición de keycodes se puede hacer de 3 maneras.  
+1. Arrastrando y soltando
+2. Clickando en un hueco vacío en el layout y haciendo click en el keycode que deseas
+3. Clickando en un hueco vacío en el layout, presionando la tecla física en tu teclado. 
+
+Mueve el puntero de tu ratón sobre una tecla y un pequeño extracto te dirá que es lo que hace la tecla. Para una descripción más detallada por favor, mira
+
+[Referencia básica de keycodes](https://docs.qmk.fm/#/keycodes_basic)    
+[Referencia avanzada de keycodes](https://docs.qmk.fm/#/feature_advanced_keycodes)    
+
+En el caso de que no puedas encontrar un layout que suporte tu keymap, por ejemplo, tres huecos para la barra espaciadora, dos huecos para el retroceso o dos huecos para shift etc etc, rellènalos TODOS. 
+
+### Ejemplo:
+
+3 huecos para barra espaciadora: Rellena TODOS con barra espaciadora
+
+2 huecos para retroceso: Rellena AMBOS con retroceso
+
+2 huecos para el shift derecho: Rellena AMBOS con shift derecho
+
+1 hueco para el shift izquierdo y 1 hueco para soporte iso: Rellena ambos con el shift izquierdo
+
+5 huecos , pero sólo 4 teclas: Intuye y comprueba o pregunta a alguien que lo haya hecho anteriormente. 
+
+## Guardando tu keymap para ediciones futuras
+
+Cuando estés satisfecho con un teclado o quieres trabajar en el después, pulsa el botón `Exportar Keymap`. Guardára tu keymap con el nombre que elijas seguido de .json. 
+
+Entonces podrás cargar este fichero .json en el futuro pulsando el botón `Importar Keymap`. 
+
+!> **PRECAUCIÓN:** No es el mismo tipo de fichero .json usado en kbfirmware.com ni ninguna otra herramienta. Si intentas utilizar un fichero .json de alguna de estas herramientas con el Configurador QMK, existe la posibilidad de que tu teclado **explote**. 
+
+## Generando tu fichero de firmware
+
+Pulsa el botón verde `Compilar`.
+
+Cuando la compilación haya acabado, podrás presionar el botón verde `Descargar Firmware`. 
+
+## Flasheando tu teclado
+
+Por favor, dirígete a la sección de [Flashear firmware](newbs_flashing.md)
+
+## Problemas comunes
+
+#### Mi fichero .json no funciona
+
+Si el fichero .json fue generado con el Configurador QMK, enhorabuena, has dado con un bug. Abre una issue en [qmk_configurator](https://github.com/qmk/qmk_configurator/issues)
+
+Si no....cómo no viste el mensaje en negrita que puse arriba diciendo que no hay que utilizar otros ficheros .json? 
+
+#### Hay espacios extra en mi layout ¿Qué hago?
+
+Si te refieres a tener tres espacios para la barra espaciadora, la mejor decisión es rellenar los tres con la barra espaciadora. También se puede hacer lo mismo con las teclas retroceso y las de shift
+
+#### Para qué sirve el keycode.......
+
+Por favor, mira
+
+[Referencia básica de keycodes](https://docs.qmk.fm/#/keycodes_basic)    
+[Referencia avanzada de keycodes](https://docs.qmk.fm/#/feature_advanced_keycodes)    
+
+#### No compila
+
+Por favor, revisa las otras capas de tu keymap para asegurarte de que no hay teclas aleatorias presentes. 
+
+## Problemas y bugs
+
+Siempre aceptamos peticiones de clientes y reportes de bug. Por favor, indícalos en [qmk_configurator](https://github.com/qmk/qmk_configurator/issues)

docs/es/newbs_flashing.md

@@ -0,0 +1,351 @@
+# Flasheando tu teclado
+
+Ahora que has construido tu fichero de firmware personalizado querrás flashear tu teclado. 
+
+## Flasheando tu teclado con QMK Toolbox
+
+La manera más simple de flashear tu teclado sería con [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases). 
+
+De todos modos, QMK Toolbox actualmente sólo está disponible para Windows y macOS.  Si estás usando Linux (o sólo quisieras flashear el firmware desde la línea de comandos), tendrás que utilizar el [método indicado abajo](newbs_flashing.md#flash-your-keyboard-from-the-command-line).
+
+### Cargar el fichero en QMK Toolbox
+
+Empieza abriendo la aplicación QMK Toolbox. Tendrás que buscar el fichero de firmware usando Finder o Explorer. El firmware de teclado puede estar en uno de estos dos formatos- `.hex` o `.bin`. QMK intenta copiar el apropiado para tu teclado en el fichero raíz `qmk_firmware`.
+
+?> Si tu estás on Windows o macOS hay comandos que puedes usar para abrir fácilmente la carpeta del firmware actual en Explorer o Finder.
+
+?> Windows:
+
+    start .
+
+?> macOS:
+
+    open .
+
+El fichero de firmware sempre sigue el siguiente formato de nombre:
+
+    <nombre_teclado>_<nombre_keymap>.{bin,hex}
+
+Por ejemplo, un `plank/rev5` con un keymap `default` tendrá este nombre de fichero:
+
+    planck_rev5_default.hex
+
+Una vez que hayas localizado el fichero de tu firmware arrástralo a la caja "Fichero local" en QMK Toolbox, o haz click en "Abrir" y navega allí donde tengas almacenado tu fichero de firmware. 
+
+### Pon tu teclado en modo DFU (Bootloader)
+
+Para poder flashear tu firmware personalizado tienes que poner tu teclado en un modo especial que permite flasheado. Cuando está en este modo no podrás teclear o utilizarlo para ninguna otra cosa. Es muy importante que no desconectes tu teclado, de lo contrario interrumpirás el proceso de flasheo mientras el firmware se está escribiendo.
+
+Diferentes teclados tienen diferentes maneras de entrar en este modo especial. Si tu PCB actualmente ejecuta QMK o TMK y no has recibido instrucciones específicas, intenta los siguientes pasos en orden:
+
+* Manten pulsadas ambas teclas shift y pulsa `Pause`
+* Manten pulsadas ambas teclas shift y pulsa `B`
+* Desconecta tu teclado, mantén pulsada la barra espaciadora y `B` al mismo tiempo, conecta tu teclado y espera un segundo antes de dejar de pulsar las teclas
+* Pulsa el botón físico `RESET` situado en el fondo de la PCB
+* Localiza los pines en la PCB etiquetados on `BOOT0` o `RESET`, puentea estos dos juntos cuando enchufes la PCB
+
+Si has tenido éxito verás un mensaje similar a este en QMK Toolbox:
+
+```
+*** Clueboard - Clueboard 66% HotSwap disconnected -- 0xC1ED:0x2390
+*** DFU device connected
+```
+
+### Flashea tu teclado
+
+Haz click en el botón `Flash` de QMK Toolbox. Verás una información de salida similar a esta:
+
+```
+*** Clueboard - Clueboard 66% HotSwap disconnected -- 0xC1ED:0x2390
+*** DFU device connected
+*** Attempting to flash, please don't remove device
+>>> dfu-programmer atmega32u4 erase --force
+    Erasing flash...  Success
+    Checking memory from 0x0 to 0x6FFF...  Empty.
+>>> dfu-programmer atmega32u4 flash /Users/skully/qmk_firmware/clueboard_66_hotswap_gen1_skully.hex
+    Checking memory from 0x0 to 0x55FF...  Empty.
+    0%                            100%  Programming 0x5600 bytes...
+    [>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]  Success
+    0%                            100%  Reading 0x7000 bytes...
+    [>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]  Success
+    Validating...  Success
+    0x5600 bytes written into 0x7000 bytes memory (76.79%).
+>>> dfu-programmer atmega32u4 reset
+    
+*** DFU device disconnected
+*** Clueboard - Clueboard 66% HotSwap connected -- 0xC1ED:0x2390
+```
+
+## Flashea tu teclado desde la línea de comandos
+
+Lo primero que tienes que saber es qué bootloader utiliza tu teclado.  Hay cuatro bootloaders pincipales que se usan habitualmente . Pro-Micro y sus clones usan CATERINA, Teensy's usa Halfkay, las placas OLKB usan QMK-DFU, y otros chips atmega32u4 usan DFU. 
+
+Puedes encontrar más información sobre bootloaders en la página [Instrucciones de flasheado e información de Bootloader](flashing.md). 
+
+Si sabes qué bootloader estás usando, en el momento de compilar el firmware, podrás añadir algún texto extra al comando `make` para automatizar el proceso de flasheado. 
+
+### DFU
+
+Para eo bootloader DFU, cuando estés listo para compilar y flashear tu firmware, abre tu ventana de terminal y ejecuta el siguiente comando de construcción: 
+
+    make <my_keyboard>:<my_keymap>:dfu
+
+Por ejemplo, si tu keymap se llama "xyverz" y estás construyendo un keymap para un planck rev5, utilizarás este comando:
+
+    make planck/rev5:xyverz:dfu
+
+Una vez que finalice de compilar, deberá aparecer lo siguiente:
+
+```
+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                                                        
+ * File size is fine - 18574/28672
+ ```
+
+Después de llegar a este punto, el script de construcción buscará el bootloader DFU cada 5 segundos.  Repetirá lo siguiente hasta que se encuentre el dispositivo o lo canceles:
+
+    dfu-programmer: no device present.
+    Error: Bootloader not found. Trying again in 5s.
+
+Una vez haya hecho esto, tendrás que reiniciar el controlador.  Debería mostrar una información de salida similar a esta: 
+
+```
+*** Attempting to flash, please don't remove device
+>>> dfu-programmer atmega32u4 erase --force
+    Erasing flash...  Success
+    Checking memory from 0x0 to 0x6FFF...  Empty.
+>>> dfu-programmer atmega32u4 flash /Users/skully/qmk_firmware/clueboard_66_hotswap_gen1_skully.hex
+    Checking memory from 0x0 to 0x55FF...  Empty.
+    0%                            100%  Programming 0x5600 bytes...
+    [>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]  Success
+    0%                            100%  Reading 0x7000 bytes...
+    [>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]  Success
+    Validating...  Success
+    0x5600 bytes written into 0x7000 bytes memory (76.79%).
+>>> dfu-programmer atmega32u4 reset
+```
+
+?> Si tienes problemas con esto- del estilo de `dfu-programmer: no device present` - por favor consulta las [Preguntas frecuentes de construcción](faq_build.md).
+
+#### Comandos DFU
+
+Hay un número de comandos DFU que puedes usar para flashear firmware a un dispositivo DFU:
+
+* `:dfu` - Esta es la opción normal y espera hasta que un dispositivo DFU esté disponible, entonces flashea el firmware. Esperará reintentando cada 5 segundos, para ver si un dispositivo DFU ha aparecido.
+* `:dfu-ee` - Esta flashea un fichero `eep` en vez del hex normal.  Esto no es lo común. 
+* `:dfu-split-left` - Esta flashea el firmware normal, igual que la opción por defecto (`:dfu`). Sin embargo, también flashea el fichero EEPROM "Lado Izquierdo" para teclados divididos. _Esto es ideal para los ficheros divididos basados en Elite C._
+* `:dfu-split-right` - Esto flashea el firmware normal, igual que la opción por defecto (`:dfu`). Sin embargo, también flashea el fichero EEPROM "Lado Derecho" para teclados divididos. _Esto es ideal para los ficheros divididos basados en Elite C._
+
+
+### Caterina 
+
+Para placas Arduino y sus clones (como la SparkFun ProMicro), cuando estés listo para compilar y flashear tu firmware, abre tu ventana de terminal y ejecuta el siguiente comando de construcción: 
+
+    make <my_keyboard>:<my_keymap>:avrdude
+
+Por ejemplo, si tu keymap se llama "xyverz" y estás construyendo un keymap para un Lets Split rev2, usarás este comando:
+
+    make lets_split/rev2:xyverz:avrdude
+
+Una vez que finalice de compilar, deberá aparecer lo siguiente:
+
+```
+Linking: .build/lets_split_rev2_xyverz.elf                                                            [OK]
+Creating load file for flashing: .build/lets_split_rev2_xyverz.hex                                    [OK]
+Checking file size of lets_split_rev2_xyverz.hex                                                      [OK]
+ * File size is fine - 27938/28672
+Detecting USB port, reset your controller now..............
+```
+
+En este punto, reinicia la placa y entonces el script detectará el bootloader y procederá a flashear la placa.  La información de salida deber ser algo similar a esto: 
+
+```
+Detected controller on USB port at /dev/ttyS15
+
+Connecting to programmer: .
+Found programmer: Id = "CATERIN"; type = S
+    Software Version = 1.0; No Hardware Version given.
+Programmer supports auto addr increment.
+Programmer supports buffered memory access with buffersize=128 bytes.
+
+Programmer supports the following devices:
+    Device code: 0x44
+
+avrdude.exe: AVR device initialized and ready to accept instructions
+
+Reading | ################################################## | 100% 0.00s
+
+avrdude.exe: Device signature = 0x1e9587 (probably m32u4)
+avrdude.exe: NOTE: "flash" memory has been specified, an erase cycle will be performed
+             To disable this feature, specify the -D option.
+avrdude.exe: erasing chip
+avrdude.exe: reading input file "./.build/lets_split_rev2_xyverz.hex"
+avrdude.exe: input file ./.build/lets_split_rev2_xyverz.hex auto detected as Intel Hex
+avrdude.exe: writing flash (27938 bytes):
+
+Writing | ################################################## | 100% 2.40s
+
+avrdude.exe: 27938 bytes of flash written
+avrdude.exe: verifying flash memory against ./.build/lets_split_rev2_xyverz.hex:
+avrdude.exe: load data flash data from input file ./.build/lets_split_rev2_xyverz.hex:
+avrdude.exe: input file ./.build/lets_split_rev2_xyverz.hex auto detected as Intel Hex
+avrdude.exe: input file ./.build/lets_split_rev2_xyverz.hex contains 27938 bytes
+avrdude.exe: reading on-chip flash data:
+
+Reading | ################################################## | 100% 0.43s
+
+avrdude.exe: verifying ...
+avrdude.exe: 27938 bytes of flash verified
+
+avrdude.exe: safemode: Fuses OK (E:CB, H:D8, L:FF)
+
+avrdude.exe done.  Thank you.
+```
+Si tienes problemas con esto, puede ser necesario que hagas esto: 
+
+    sudo make <my_keyboard>:<my_keymap>:avrdude
+
+
+Adicionalmente, si quisieras flashear múltiples placas, usa el siguiente comando:
+
+    make <keyboard>:<keymap>:avrdude-loop
+
+Cuando hayas acabado de flashear placas, necesitarás pulsar Ctrl + C o cualquier combinación que esté definida en tu sistema operativo para finalizar el bucle.
+
+
+### HalfKay
+
+Para dispositivos PJRC (Teensy's), cuando estés listo para compilar y flashear tu firmware, abre tu ventana de terminal y ejecuta el siguiente comando de construcción: 
+
+    make <my_keyboard>:<my_keymap>:teensy
+
+Por ejemplo, si tu keymap se llama "xyverz" y estás construyendo un keymap para un Ergodox o un Ergodox EZ, usarás este comando:
+
+    make ergodox_ez:xyverz:teensy
+
+Una vez que el firmware acabe de compilar, deberá mostrar una información de salida como esta: 
+
+```
+Linking: .build/ergodox_ez_xyverz.elf                                                               [OK]
+Creating load file for flashing: .build/ergodox_ez_xyverz.hex                                       [OK]
+Checking file size of ergodox_ez_xyverz.hex                                                         [OK]
+ * File size is fine - 25584/32256
+ Teensy Loader, Command Line, Version 2.1
+Read "./.build/ergodox_ez_xyverz.hex": 25584 bytes, 79.3% usage
+Waiting for Teensy device...
+ (hint: press the reset button)
+ ```
+
+En este punto, reinicia tu placa.  Una vez que lo hayas hecho, deberás ver una información de salida como esta: 
+
+ ```
+ Found HalfKay Bootloader
+Read "./.build/ergodox_ez_xyverz.hex": 28532 bytes, 88.5% usage
+Programming............................................................................................................................................................................
+...................................................
+Booting
+```
+
+### BootloadHID
+
+Para placas basadas en Bootmapper Client(BMC)/bootloadHID/ATmega32A, cuando estés listo para compilar y flashear tu firmware, abre tu ventana de terminal y ejecuta el comando de construcción: 
+
+    make <my_keyboard>:<my_keymap>:bootloaderHID
+
+Por ejemplo, si tu keymap se llama "xyverz" y estás construyendo un keymap para un jj40, usarás esté comando:
+
+    make jj40:xyverz:bootloaderHID
+
+Una vez que el firmware acaba de compilar, mostrará una información de salida como esta: 
+
+```
+Linking: .build/jj40_default.elf                                                                   [OK]
+Creating load file for flashing: .build/jj40_default.hex                                           [OK]
+Copying jj40_default.hex to qmk_firmware folder                                                    [OK]
+Checking file size of jj40_default.hex                                                             [OK]
+ * The firmware size is fine - 21920/28672 (6752 bytes free)
+```
+
+Después de llegar a este punto, el script de construcción buscará el bootloader DFU cada 5 segundos.  Repetirá lo siguiente hasta que se encuentre el dispositivo o hasta que lo canceles. 
+
+```
+Error opening HIDBoot device: The specified device was not found
+Trying again in 5s.
+```
+
+Una vez que lo haga, querrás reinicar el controlador.  Debería entonces mostrar una información de salida similar a esta: 
+
+```
+Page size   = 128 (0x80)
+Device size = 32768 (0x8000); 30720 bytes remaining
+Uploading 22016 (0x5600) bytes starting at 0 (0x0)
+0x05580 ... 0x05600
+```
+
+### STM32 (ARM)
+
+Para la mayoría de placas ARM (incluyendo la Proton C, Planck Rev 6, y Preonic Rev 3), cuando estés listo para compilar y flashear tu firmware, abre tu ventana de terminal y ejecuta el siguiente comando de construcción:
+
+    make <my_keyboard>:<my_keymap>:dfu-util
+
+Por ejemplo, si tu keymap se llama "xyverz" y estás construyendo un keymap para un teclado Planck Revision 6, utilizarás este comando y a continuación reiniciarás el teclado con el bootloader (antes de que acabe de compilar):
+
+    make planck/rev6:xyverz:dfu-util
+
+Una vez que el firmware acaba de compilar, mostrará una información de salida similar a esta: 
+
+```
+Linking: .build/planck_rev6_xyverz.elf                                                             [OK]
+Creating binary load file for flashing: .build/planck_rev6_xyverz.bin                               [OK]
+Creating load file for flashing: .build/planck_rev6_xyverz.hex                                     [OK]
+
+Size after:
+   text    data     bss     dec     hex filename
+      0   41820       0   41820    a35c .build/planck_rev6_xyverz.hex
+
+Copying planck_rev6_xyverz.bin to qmk_firmware folder                                              [OK]
+dfu-util 0.9
+
+Copyright 2005-2009 Weston Schmidt, Harald Welte and OpenMoko Inc.
+Copyright 2010-2016 Tormod Volden and Stefan Schmidt
+This program is Free Software and has ABSOLUTELY NO WARRANTY
+Please report bugs to http://sourceforge.net/p/dfu-util/tickets/
+
+Invalid DFU suffix signature
+A valid DFU suffix will be required in a future dfu-util release!!!
+Opening DFU capable USB device...
+ID 0483:df11
+Run-time device DFU version 011a
+Claiming USB DFU Interface...
+Setting Alternate Setting #0 ...
+Determining device status: state = dfuERROR, status = 10
+dfuERROR, clearing status
+Determining device status: state = dfuIDLE, status = 0
+dfuIDLE, continuing
+DFU mode device DFU version 011a
+Device returned transfer size 2048
+DfuSe interface name: "Internal Flash  "
+Downloading to address = 0x08000000, size = 41824
+Download        [=========================] 100%        41824 bytes
+Download done.
+File downloaded successfully
+Transitioning to dfuMANIFEST state
+```
+
+#### STM32 Commands
+
+Hay un número de comandos DFU que puedes usar para flashear firmware a un dispositivo DFU:
+
+* `:dfu-util` - El comando por defecto para flashing en dispositivos STM32. 
+* `:dfu-util-wait` - Esto funciona como el comando por defecto, pero te da (configurable) 10 segundos de tiempo antes de que intente flashear el firmware.  Puedes usar `TIME_DELAY=20` desde la líena de comandos para cambiar este tiempo de retardo.
+   * Eg: `make <keyboard>:<keymap>:dfu-util TIME_DELAY=5`
+* `:dfu-util-split-left` - Flashea el firmware normal, igual que la opción por defecto (`:dfu-util`). Sin embargo, también flashea el fichero EEPROM "Lado Izquierdo" para teclados divididos.
+* `:dfu-util-split-right` - Flashea el firmware normal, igual que la opción por defecto (`:dfu-util`). Sin embargo, también flashea el fichero EEPROM "Lado Derecho" para teclados divididos.
+
+## ¡Pruébalo!
+
+¡Felicidades! ¡Tu firmware personalizado ha sido programado en tu teclado!
+
+Pruébalo y asegúrate de que todo funciona de la manera que tu quieres. Hemos escrito [Testeando y depurando](newbs_testing_debugging.md) para redondear esta guía de novatos, así que pásate por allí para aprender cómo resolver problemas con tu funcionalidad personalizada.

docs/es/newbs_getting_started.md

@@ -0,0 +1,103 @@
+# Introducción
+
+El teclado de tu computador tiene un procesador dentro de él, no muy distinto del que está dentro de tu ordenador. Este procesador ejecuta software que es responsable de detectar la pulsación de las teclas y enviar informes sobre el estado del teclado cuando las teclas son pulsadas y liberadas. QMK ocupa el rol de ese software. Cuando construyes un keymap personalizado , estas creando el equivalente de un programa ejecutable en tu teclado.
+
+QMK intenta poner un montón de poder en tus manos haciendo que las cosas fáciles sean fáciles, y las cosas difíciles posibles. No tienes que saber cómo programar para crear keymaps potentes — sólo tienes que seguir un conjunto simple de reglas sintácticas.
+
+# Comenzando
+
+Antes de que puedas construir keymaps, necesitarás instalar algun software y configurar tu entorno de construcción. Esto sólo hay que hacerlo una vez sin importar en cuántos teclados planeas configurar el software. 
+
+Si prefieres hacerlo mediante un interfaz gráfico , por favor, considera utilizar el [Configurador QMK](https://config.qmk.fm). En ese caso dirígete a [Construyendo tu primer firmware usando la GUI](newbs_building_firmware_configurator.md). 
+
+
+## Descarga el software
+
+### Editor de texto
+
+Necesitarás un programa con el que puedas editar y guardar archivos de **texto plano**, en windows puedes utilizar Notepad y en tu Linux puedes utilizar gedit. Estos dos programas son editores simples y funcionales. En macOS ten cuidado con la aplicación de edición de texto por defecto TextEdit: no guardará texto plano a menos de que se le seleccione explícitamente _Make Plain Text_ desde el menú _Format_.
+
+También puedes descargar e instalar un editor de texto dedicado como [Sublime Text](https://www.sublimetext.com/) o [VS Code](https://code.visualstudio.com/). Esta es probablemente la mejor manera independientemente de la plataforma, ya que estos programas fueron creados específicamente para editar código.
+
+?> ¿No estás seguro de qué editor de texto utilizar? Laurence Bradford escribió una [estupenda introducción](https://learntocodewith.me/programming/basics/text-editors/) al tema.
+
+### QMK Toolbox
+
+QMK Toolbox is an optional graphical program for Windows and macOS that allows you to both program and debug your custom keyboard. You will likely find it invaluable for easily flashing your keyboard and viewing debug messages that it prints.
+
+[Download the latest release here.](https://github.com/qmk/qmk_toolbox/releases/latest)
+
+* For Windows: `qmk_toolbox.exe` (portable) or `qmk_toolbox_install.exe` (installer)
+* For macOS: `QMK.Toolbox.app.zip` (portable) or `QMK.Toolbox.pkg` (installer)
+
+## Configura tu entorno
+
+Hemos intentado hacer QMK lo más fácil de configurar posible. Sólo tienes que preparar tu entorno Linux o Unix, y luego dejar que QMK
+instale el resto.
+
+?> Si no has trabajado con la línea de comandos de Linux/Unix con anterioridad, hay algunos conceptos y comandos básicos que deberías aprender. Estos recursos te enseñarán lo suficiente para poder trabajar con QMK:<br>
+[Comandos de Linux que debería saber](https://www.guru99.com/must-know-linux-commands.html)<br>
+[Algunos comandos básicos de Unix](https://www.tjhsst.edu/~dhyatt/superap/unixcmd.html)
+
+### Windows
+
+Necesitarás instalar MSYS2 y Git.
+
+* Sigue las instrucciones de instalación en la [página de MSYS2](http://www.msys2.org).
+* Cierra las terminales abiertas de MSYS2 y abre una nueva termial de MSYS2 MinGW 64-bit.
+* Instala Git ejecutando este comando: `pacman -S git`.
+
+### macOS
+
+Necesitarás instalar Homebrew. Sigue las instrucciones que encontrarás en la [página de Homebrew](https://brew.sh).
+
+Despueś de que se haya inastalado Homebrew, continúa con _Set Up QMK_. En ese paso ejecutará un script que instalará el resto de paquetes.
+
+### Linux
+
+Necesitarás instalar Git. Es bastante probable que ya lo tengas, pero si no, uno de los siguientes comandos debería instalarlo:
+
+* Debian / Ubuntu / Devuan: `apt-get install git`
+* Fedora / Red Hat / CentOS: `yum install git`
+* Arch: `pacman -S git`
+
+?> Docker es también una opción en todas las plataformas. [Haz click aquí si quieres detalles.](getting_started_build_tools.md#docker)
+
+## Configura QMK
+
+Una vez que hayas configurado tu entorno Linux/Unix, estarás listo para descargar QMK. Haremos esto utilizando Git para "clonar" el respositorio de QMK. Abre una ventana de Terminal o MSYS2 MinGW y mantenla abierta mientras sigues esta guía. Dentro de esa ventana ejecuta estos dos comandos:
+
+```shell
+git clone --recurse-submodules https://github.com/qmk/qmk_firmware.git
+cd qmk_firmware
+```
+
+?> Si ya sabes [cómo usar GitHub](getting_started_github.md), te recomendamos en vez de eso, crees y clones tu propio fork. Si no sabes lo que significa, puedes ignorar este mensaje sin problemas.
+
+QMK viene con un script para ayudarte a configurar el resto de cosas que necesitarás. Deberías ejecutarlo introduciendo este comando:
+
+    util/qmk_install.sh
+
+## Prueba tu entorno de construcción
+
+Ahora que tu entorno de construcción de QMK está configurado, puedes construcir un firmware para tu teclado. Comienza intentado construir el keymap por defecto del teclado. Deberías ser capaz de hacerlo con un comando con este formato:
+
+    make <keyboard>:default
+
+Por ejemplo, para construir el firmware para un Clueboard 66% deberías usar:
+
+    make clueboard/66/rev3:default
+
+Cuando esté hecho, deberías tener un montón de información de salida similar a esta:
+
+```
+Linking: .build/clueboard_66_rev3_default.elf                                                       [OK]
+Creating load file for flashing: .build/clueboard_66_rev3_default.hex                               [OK]
+Copying clueboard_66_rev3_default.hex to qmk_firmware folder                                        [OK]
+Checking file size of clueboard_66_rev3_default.hex                                                 [OK]
+ * The firmware size is fine - 26356/28672 (2316 bytes free)
+```
+
+# Creando tu keymap
+
+Ya estás listo para crear tu propio keymap personal! Para hacerlo continua con [Construyendo tu primer firmware](newbs_building_firmware.md).

docs/es/newbs_learn_more_resources.md

@@ -0,0 +1,15 @@
+# Recursos de aprendizaje
+
+Estos recursos procuran dar miembros nuevos en la communidad QMK un mayor entendimiento de la información proporcionada en la documentación para novatos.
+
+Recursos de Git:
+
+* [Excelente tutorial general](https://www.codecademy.com/learn/learn-git)
+* [Juego de Git para aprender usando ejemplos](https://learngitbranching.js.org/)
+* [Recursos de Git para aprender más sobre Github](getting_started_github.md)
+* [Recursos de Git dirigidos específicamente a QMK](contributing.md)
+
+
+Recursos para línea de mandatos:
+
+* [Excelente tutorial general sobre la línea de mandatos](https://www.codecademy.com/learn/learn-the-command-line)

docs/es/newbs_testing_debugging.md

@@ -0,0 +1,99 @@
+# Testeando y depurando
+
+Una vez que hayas flasheado tu teclado con un firmware personalizado estarás listo para probarlo. Con un poco de suerte todo funcionará a la primera, pero si no es así, este documento te ayudará a averiguar qué está mal.
+
+## Probando
+
+Probar tu teclado es generalmente bastante sencillo. Persiona cada una de las teclas y asegúrate de que envía la tecla correcta. Existen incluso programas que te ayudarán a asegurarte de que no te dejas ninguna tecla sin comprobar.
+
+Nota: Estos programas no los provée ni están relacionados con QMK.
+
+* [Switch Hitter](https://elitekeyboards.com/switchhitter.php) (Sólo Windows)
+* [Keyboard Viewer](https://www.imore.com/how-use-keyboard-viewer-your-mac) (Sólo Mac)
+* [Keyboard Tester](http://www.keyboardtester.com) (Aplicación web)
+* [Keyboard Checker](http://keyboardchecker.com) (Aplicación web)
+
+## Depurando
+
+Tu teclado mostrará información de depuración si tienes `CONSOLE_ENABLE = yes` en tu `rules.mk`. Por defecto la información de salida es muy limitada, pero puedes encender el modo de depuración para incrementar la información de salida. Utiliza el keycode `DEBUG` de tu keymap, usa la característica [Comando](feature_command.md) para activar el modo depuración, o añade el siguiente código a tu keymap.
+
+```c
+void keyboard_post_init_user(void) {
+  // Customise these values to desired behaviour
+  debug_enable=true;
+  debug_matrix=true;
+  //debug_keyboard=true;
+  //debug_mouse=true;
+}
+```
+
+### Depurando con QMK Toolbox
+
+Para plataformas compatibles, [QMK Toolbox](https://github.com/qmk/qmk_toolbox) se puede usar para mostrar mensajes de depuración de tu teclado.
+
+### Depurando con hid_listen
+
+¿Prefieres una solución basada en una terminal? [hid_listen](https://www.pjrc.com/teensy/hid_listen.html), provista por PJRC, se puede usar también para mostrar mensajes de depuración. Hay binarios preconstruídos para Windows,Linux,y MacOS.
+
+<!-- FIXME: Describe the debugging messages here. -->
+
+## Enviando tus propios mensajes de depuración
+
+A veces, es útil imprimir mensajes de depuración desde tu [código personalizado](custom_quantum_functions.md). Hacerlo es bastante simple. Comienza incluyendo `print.h` al principio de tu fichero:
+
+    #include <print.h>
+
+Después de eso puedes utilzar algunas funciones print diferentes:
+
+* `print("string")`: Imprime un string simple
+* `uprintf("%s string", var)`: Imprime un string formateado
+* `dprint("string")` Imprime un string simple, pero sólo cuando el modo de depuración está activo
+* `dprintf("%s string", var)`: Imprime un string formateado, pero sólo cuando el modo de depuración está activo
+
+## Ejemplos de depuración
+
+Debajo hay una colección de ejemplos de depuración del mundo real. Para información adicional, Dirígete a [Depurando/Encontrando problemas en QMK](faq_debug.md).
+
+### ¿Que posición en la matriz tiene esta pulsación de tecla?
+
+Cuando estés portando, o intentando diagnosticar problemas en la pcb, puede ser útil saber si la pulsación de una tecla es escaneada correctamente. Para hablitar la información de registro en este escenario, añade el siguiente código al `keymap.c` de tus keymaps
+
+```c
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  // If console is enabled, it will print the matrix position and status of each key pressed
+#ifdef CONSOLE_ENABLE
+    uprintf("KL: kc: %u, col: %u, row: %u, pressed: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed);
+#endif 
+  return true;
+}
+```
+
+Ejemplo de salida
+```text
+Waiting for device:.......
+Listening:
+KL: kc: 169, col: 0, row: 0, pressed: 1
+KL: kc: 169, col: 0, row: 0, pressed: 0
+KL: kc: 174, col: 1, row: 0, pressed: 1
+KL: kc: 174, col: 1, row: 0, pressed: 0
+KL: kc: 172, col: 2, row: 0, pressed: 1
+KL: kc: 172, col: 2, row: 0, pressed: 0
+```
+
+### ¿Cuanto tiempo tardó en escanear la pulsación de una tecla?
+
+Cuando estés probando problemas en el rendimiento, puede ser útil saber la frecuenta a la cual la matríz de pulsadores se está escaneando. Para hablitar la información de registro en este escenario, añade el siguiente código al `config.h` de tus keymaps
+
+```c
+#define DEBUG_MATRIX_SCAN_RATE
+```
+
+Ejemplo de salida
+```text
+  > matrix scan frequency: 315
+  > matrix scan frequency: 313
+  > matrix scan frequency: 316
+  > matrix scan frequency: 316
+  > matrix scan frequency: 316
+  > matrix scan frequency: 316
+```

docs/feature_auto_shift.md

@@ -51,12 +51,15 @@ By default, Auto Shift is disabled for any key press that is accompanied by one
 modifiers. Thus, Ctrl+A that you hold for a really long time is not the same
 as Ctrl+Shift+A.
 
-You can re-enable Auto Shift for modifiers by adding another rule to your `rules.mk`
+You can re-enable Auto Shift for modifiers by adding a define to your `config.h`
 
-    AUTO_SHIFT_MODIFIERS = yes
+```c
+#define AUTO_SHIFT_MODIFIERS
+```
 
 In which case, Ctrl+A held past the `AUTO_SHIFT_TIMEOUT` will be sent as Ctrl+Shift+A
 
+
 ## Configuring Auto Shift
 
 If desired, there is some configuration that can be done to change the
@@ -65,15 +68,12 @@ behavior of Auto Shift. This is done by setting various variables the
 
 A sample is
 
-    #ifndef CONFIG_USER_H
-    #define CONFIG_USER_H
+```c
+#pragma once
 
-    #include "../../config.h"
-
-    #define AUTO_SHIFT_TIMEOUT 150
-    #define NO_AUTO_SHIFT_SPECIAL
-
-    #endif
+#define AUTO_SHIFT_TIMEOUT 150
+#define NO_AUTO_SHIFT_SPECIAL
+```
 
 ### AUTO_SHIFT_TIMEOUT (Value in ms)
 

docs/feature_backlight.md

@@ -6,14 +6,16 @@ QMK is able to control the brightness of these LEDs by switching them on and off
 
 The MCU can only supply so much current to its GPIO pins. Instead of powering the backlight directly from the MCU, the backlight pin is connected to a transistor or MOSFET that switches the power to the LEDs.
 
-## Usage
+## Driver configuration
 
 Most keyboards have backlighting enabled by default if they support it, but if it is not working for you, check that your `rules.mk` includes the following:
 
-```make
-BACKLIGHT_ENABLE = yes
+```makefile
+BACKLIGHT_ENABLE = software # Valid driver values are 'yes,software,no'
 ```
 
+See below for help on individual drivers.
+
 ## Keycodes
 Once enabled the following keycodes below can be used to change the backlight level.
 
@@ -27,8 +29,54 @@ Once enabled the following keycodes below can be used to change the backlight le
 |`BL_DEC` |Decrease the backlight level              |
 |`BL_BRTG`|Toggle backlight breathing                |
 
+## Backlight Functions
+
+|Function  |Description                                                |
+|----------|-----------------------------------------------------------|
+|`backlight_toggle()`    |Turn the backlight on or off                 |
+|`backlight_enable()`    |Turn the backlight on                        |
+|`backlight_disable()`   |Turn the backlight off                       |
+|`backlight_step()`      |Cycle through backlight levels               |
+|`backlight_increase()`  |Increase the backlight level                 |
+|`backlight_decrease()`  |Decrease the backlight level                 |
+|`backlight_level(x)`    |Sets the backlight level to specified level  |
+|`get_backlight_level()` |Return the current backlight level           |
+|`is_backlight_enabled()`|Return whether the backlight is currently on |
+
+### Backlight Breathing Functions
+
+|Function  |Description                                        |
+|----------|---------------------------------------------------|
+|`breathing_toggle()`  |Turn the backlight breathing on or off |
+|`breathing_enable()`  |Turns on backlight breathing           |
+|`breathing_disable()` |Turns off backlight breathing          |
+
+## Common Driver Configuration
+
+To change the behavior of the backlighting, `#define` these in your `config.h`:
+
+|Define               |Default      |Description                                                                           |
+|---------------------|-------------|--------------------------------------------------------------------------------------|
+|`BACKLIGHT_LEVELS`   |`3`          |The number of brightness levels (maximum 31 excluding off)                            |
+|`BACKLIGHT_CAPS_LOCK`|*Not defined*|Enable Caps Lock indicator using backlight (for keyboards without dedicated LED)      |
+|`BACKLIGHT_BREATHING`|*Not defined*|Enable backlight breathing, if supported                                              |
+|`BREATHING_PERIOD`   |`6`          |The length of one backlight "breath" in seconds                                       |
+|`BACKLIGHT_ON_STATE` |`0`          |The state of the backlight pin when the backlight is "on" - `1` for high, `0` for low |
+
+### Backlight On State
+
+Most backlight circuits are driven by an N-channel MOSFET or NPN transistor. This means that to turn the transistor *on* and light the LEDs, you must drive the backlight pin, connected to the gate or base, *high*.
+Sometimes, however, a P-channel MOSFET, or a PNP transistor is used. In this case, when the transistor is on, the pin is driven *low* instead.
+
+This functionality is configured at the keyboard level with the `BACKLIGHT_ON_STATE` define.
+
 ## AVR driver
 
+On AVR boards, the default driver currently sniffs the configuration to pick the best scenario. To enable it, add this to your rules.mk:
+```makefile
+BACKLIGHT_ENABLE = yes
+```
+
 ### Caveats
 
 Hardware PWM is supported according to the following table:
@@ -63,22 +111,10 @@ When both timers are in use for Audio, the backlight PWM will not use a hardware
 
 To change the behavior of the backlighting, `#define` these in your `config.h`:
 
-|Define               |Default      |Description                                                                                                  |
-|---------------------|-------------|-------------------------------------------------------------------------------------------------------------|
-|`BACKLIGHT_PIN`      |`B7`         |The pin that controls the LEDs. Unless you are designing your own keyboard, you shouldn't need to change this|
-|`BACKLIGHT_PINS`     |*Not defined*|experimental: see below for more information                                                                 |
-|`BACKLIGHT_LEVELS`   |`3`          |The number of brightness levels (maximum 31 excluding off)                                                   |
-|`BACKLIGHT_CAPS_LOCK`|*Not defined*|Enable Caps Lock indicator using backlight (for keyboards without dedicated LED)                             |
-|`BACKLIGHT_BREATHING`|*Not defined*|Enable backlight breathing, if supported                                                                     |
-|`BREATHING_PERIOD`   |`6`          |The length of one backlight "breath" in seconds                                                              |
-|`BACKLIGHT_ON_STATE` |`0`          |The state of the backlight pin when the backlight is "on" - `1` for high, `0` for low                        |
-
-### Backlight On State
-
-Most backlight circuits are driven by an N-channel MOSFET or NPN transistor. This means that to turn the transistor *on* and light the LEDs, you must drive the backlight pin, connected to the gate or base, *high*.
-Sometimes, however, a P-channel MOSFET, or a PNP transistor is used. In this case, when the transistor is on, the pin is driven *low* instead.
-
-This functionality is configured at the keyboard level with the `BACKLIGHT_ON_STATE` define.
+|Define               |Default      |Description                                                                                                   |
+|---------------------|-------------|--------------------------------------------------------------------------------------------------------------|
+|`BACKLIGHT_PIN`      |`B7`         |The pin that controls the LEDs. Unless you are designing your own keyboard, you shouldn't need to change this |
+|`BACKLIGHT_PINS`     |*Not defined*|experimental: see below for more information                                                                  |
 
 ### Multiple backlight pins
 
@@ -103,7 +139,7 @@ In this way `OCRxx` essentially controls the duty cycle of the LEDs, and thus th
 The breathing effect is achieved by registering an interrupt handler for `TIMER1_OVF_vect` that is called whenever the counter resets, roughly 244 times per second.
 In this handler, the value of an incrementing counter is mapped onto a precomputed brightness curve. To turn off breathing, the interrupt handler is simply disabled, and the brightness reset to the level stored in EEPROM.
 
-### Software PWM Implementation
+### Timer Assisted PWM Implementation
 
 When `BACKLIGHT_PIN` is not set to a hardware backlight pin, QMK will use a hardware timer configured to trigger software interrupts. This time will count up to `ICRx` (by default `0xFFFF`) before resetting to 0.
 When resetting to 0, the CPU will fire an OVF (overflow) interrupt that will turn the LEDs on, starting the duty cycle.
@@ -114,9 +150,14 @@ The breathing effect is the same as in the hardware PWM implementation.
 
 ## ARM Driver
 
+While still in its early stages, ARM backlight support aims to eventually have feature parity with AVR. To enable it, add this to your rules.mk:
+```makefile
+BACKLIGHT_ENABLE = yes
+```
+
 ### Caveats
 
-Currently only hardware PWM is supported, and does not provide automatic configuration.
+Currently only hardware PWM is supported, not timer assisted, and does not provide automatic configuration.
 
 ?> STMF072 support is being investigated.
 
@@ -130,30 +171,32 @@ To change the behavior of the backlighting, `#define` these in your `config.h`:
 |`BACKLIGHT_PWM_DRIVER`  |`PWMD4`      |The PWM driver to use, see ST datasheets for pin to PWM timer mapping. Unless you are designing your own keyboard, you shouldn't need to change this|
 |`BACKLIGHT_PWM_CHANNEL` |`3`          |The PWM channel to use, see ST datasheets for pin to PWM channel mapping. Unless you are designing your own keyboard, you shouldn't need to change this|
 |`BACKLIGHT_PAL_MODE`    |`2`          |The pin alternative function to use, see ST datasheets for pin AF mapping. Unless you are designing your own keyboard, you shouldn't need to change this|
-|`BACKLIGHT_LEVELS`      |`3`          |The number of brightness levels (maximum 31 excluding off)                                                   |
-|`BACKLIGHT_CAPS_LOCK`   |*Not defined*|Enable Caps Lock indicator using backlight (for keyboards without dedicated LED)                             |
-|`BACKLIGHT_BREATHING`   |*Not defined*|Enable backlight breathing, if supported                                                                     |
-|`BREATHING_PERIOD`      |`6`          |The length of one backlight "breath" in seconds                                                              |
 
-## Backlight Functions
+## Software PWM Driver
 
-|Function  |Description                                                |
-|----------|-----------------------------------------------------------|
-|`backlight_toggle()`    |Turn the backlight on or off                 |
-|`backlight_enable()`    |Turn the backlight on                        |
-|`backlight_disable()`   |Turn the backlight off                       |
-|`backlight_step()`      |Cycle through backlight levels               |
-|`backlight_increase()`  |Increase the backlight level                 |
-|`backlight_decrease()`  |Decrease the backlight level                 |
-|`backlight_level(x)`    |Sets the backlight level, from 0 to          |
-|                        |`BACKLIGHT_LEVELS`                           |
-|`get_backlight_level()` |Return the current backlight level           |
-|`is_backlight_enabled()`|Return whether the backlight is currently on |
+Emulation of PWM while running other keyboard tasks, it offers maximum hardware compatibility without extra platform configuration. The tradeoff is the backlight might jitter when the keyboard is busy. To enable, add this to your rules.mk:
+```makefile
+BACKLIGHT_ENABLE = software
+```
 
-### Backlight Breathing Functions
+### Software PWM Configuration
 
-|Function  |Description                                               |
-|----------|----------------------------------------------------------|
-|`breathing_toggle()`  |Turn the backlight breathing on or off        |
-|`breathing_enable()`  |Turns on backlight breathing                  |
-|`breathing_disable()` |Turns off backlight breathing                 |
+To change the behavior of the backlighting, `#define` these in your `config.h`:
+
+|Define           |Default      |Description                                                                                                  |
+|-----------------|-------------|-------------------------------------------------------------------------------------------------------------|
+|`BACKLIGHT_PIN`  |`B7`         |The pin that controls the LEDs. Unless you are designing your own keyboard, you shouldn't need to change this|
+|`BACKLIGHT_PINS` |*Not defined*|experimental: see below for more information                                                                 |
+
+### Multiple backlight pins
+
+Most keyboards have only one backlight pin which control all backlight LEDs (especially if the backlight is connected to an hardware PWM pin).
+In software PWM, it is possible to define multiple backlight pins. All those pins will be turned on and off at the same time during the PWM duty cycle.
+This feature allows to set for instance the Caps Lock LED (or any other controllable LED) brightness at the same level as the other LEDs of the backlight. This is useful if you have mapped LCTRL in place of Caps Lock and you need the Caps Lock LED to be part of the backlight instead of being activated when Caps Lock is on.
+
+To activate multiple backlight pins, you need to add something like this to your user `config.h`:
+
+```c
+#undef BACKLIGHT_PIN
+#define BACKLIGHT_PINS { F5, B2 }
+```

docs/feature_dynamic_macros.md

@@ -4,51 +4,45 @@ QMK supports temporary macros created on the fly. We call these Dynamic Macros.
 
 You can store one or two macros and they may have a combined total of 128 keypresses. You can increase this size at the cost of RAM.
 
-To enable them, first add a new element to the end of your `keycodes` enum — `DYNAMIC_MACRO_RANGE`:
+To enable them, first include `DYNAMIC_MACRO_ENABLE = yes` in your `rules.mk`. Then, add the following keys to your keymap:
 
-```c
-enum keycodes {
-	QWERTY = SAFE_RANGE,
-	COLEMAK,
-	DVORAK,
-	PLOVER,
-	LOWER,
-	RAISE,
-	BACKLIT,
-	EXT_PLV,
-	DYNAMIC_MACRO_RANGE,
-};
-```
+|Key               |Alias     |Description                                        |
+|------------------|----------|---------------------------------------------------|
+|`DYN_REC_START1`  |`DM_REC1` |Start recording Macro 1                            |
+|`DYN_REC_START2`  |`DM_REC2` |Start recording Macro 2                            |
+|`DYN_MACRO_PLAY1` |`DM_PLY1` |Replay Macro 1                                     |
+|`DYN_MACRO_PLAY2` |`DM_PLY2` |Replay Macro 2                                     |
+|`DYN_REC_STOP`    |`DM_RSTP` |Finish the macro that is currently being recorded. |
 
-Your `keycodes` enum may have a slightly different name. You must add `DYNAMIC_MACRO_RANGE` as the last element because `dynamic_macros.h` will add some more keycodes after it.
+That should be everything necessary. 
 
-Below it, include the `dynamic_macro.h` header:
+To start recording the macro, press either `DYN_REC_START1` or `DYN_REC_START2`. 
 
-```c
-	#include "dynamic_macro.h"`
-```
+To finish the recording, press the `DYN_REC_STOP` layer button. 
 
-Add the following keys to your keymap:
+To replay the macro, press either `DYN_MACRO_PLAY1` or `DYN_MACRO_PLAY2`.
 
-* `DYN_REC_START1` — start recording the macro 1,
-* `DYN_REC_START2` — start recording the macro 2,
-* `DYN_MACRO_PLAY1` — replay the macro 1,
-* `DYN_MACRO_PLAY2` — replay the macro 2,
-* `DYN_REC_STOP` — finish the macro that is currently being recorded.
+It is possible to replay a macro as part of a macro. It's ok to replay macro 2 while recording macro 1 and vice versa but never create recursive macros i.e. macro 1 that replays macro 1. If you do so and the keyboard will get unresponsive, unplug the keyboard and plug it again.  You can disable this completly by defining `DYNAMIC_MACRO_NO_NESTING`  in your `config.h` file.
 
-Add the following code to the very beginning of your `process_record_user()` function:
+?> For the details about the internals of the dynamic macros, please read the comments in the `process_dynamic_macro.h` and `process_dynamic_macro.c` files.
 
-```c
-	if (!process_record_dynamic_macro(keycode, record)) {
-		return false;
-	}
-```
+## Customization 
 
-That should be everything necessary. To start recording the macro, press either `DYN_REC_START1` or `DYN_REC_START2`. To finish the recording, press the `DYN_REC_STOP` layer button. To replay the macro, press either `DYN_MACRO_PLAY1` or `DYN_MACRO_PLAY2`.
+There are a number of options added that should allow some additional degree of customization
 
-Note that it's possible to replay a macro as part of a macro. It's ok to replay macro 2 while recording macro 1 and vice versa but never create recursive macros i.e. macro 1 that replays macro 1. If you do so and the keyboard will get unresponsive, unplug the keyboard and plug it again.
+|Define                      |Default         |Description                                                                                                      |
+|----------------------------|----------------|-----------------------------------------------------------------------------------------------------------------|
+|`DYNAMIC_MACRO_SIZE`        |128             |Sets the amount of memory that Dynamic Macros can use. This is a limited resource, dependent on the controller.  |
+|`DYNAMIC_MACRO_USER_CALL`   |*Not defined*   |Defining this falls back to using the user `keymap.c` file to trigger the macro behavior.                        |
+|`DYNAMIC_MACRO_NO_NESTING`  |*Not Defined*   |Defining this disables the ability to call a macro from another macro (nested macros).                           | 
 
-For users of the earlier versions of dynamic macros: It is still possible to finish the macro recording using just the layer modifier used to access the dynamic macro keys, without a dedicated `DYN_REC_STOP` key. If you want this behavior back, use the following snippet instead of the one above:
+
+If the LEDs start blinking during the recording with each keypress, it means there is no more space for the macro in the macro buffer. To fit the macro in, either make the other macro shorter (they share the same buffer) or increase the buffer size by adding the `DYNAMIC_MACRO_SIZE` define in your `config.h` (default value: 128; please read the comments for it in the header).
+
+
+### DYNAMIC_MACRO_USER_CALL
+
+For users of the earlier versions of dynamic macros: It is still possible to finish the macro recording using just the layer modifier used to access the dynamic macro keys, without a dedicated `DYN_REC_STOP` key. If you want this behavior back, add `#define DYNAMIC_MACRO_USER_CALL` to your `config.h` and insert the following snippet at the beginning of your `process_record_user()` function:
 
 ```c
 	uint16_t macro_kc = (keycode == MO(_DYN) ? DYN_REC_STOP : keycode);
@@ -58,6 +52,15 @@ For users of the earlier versions of dynamic macros: It is still possible to fin
 	}
 ```
 
-If the LEDs start blinking during the recording with each keypress, it means there is no more space for the macro in the macro buffer. To fit the macro in, either make the other macro shorter (they share the same buffer) or increase the buffer size by setting the `DYNAMIC_MACRO_SIZE` preprocessor macro (default value: 128; please read the comments for it in the header).
+### User Hooks
 
-For the details about the internals of the dynamic macros, please read the comments in the `dynamic_macro.h` header.
+There are a number of hooks that you can use to add custom functionality and feedback options to Dynamic Macro feature.  This allows for some additional degree of customization. 
+
+Note, that direction indicates which macro it is, with `1` being Macro 1, `-1` being Macro 2, and 0 being no macro. 
+
+* `dynamic_macro_record_start_user(void)` - Triggered when you start recording a macro.
+* `dynamic_macro_play_user(int8_t direction)` - Triggered when you play back a macro.
+* `dynamic_macro_record_key_user(int8_t direction, keyrecord_t *record)` - Triggered on each keypress while recording a macro.
+* `dynamic_macro_record_end_user(int8_t direction)` - Triggered when the macro recording is stopped. 
+
+Additionally, you can call `dynamic_macro_led_blink()` to flash the backlights if that feature is enabled. 

docs/feature_haptic_feedback.md

@@ -22,7 +22,7 @@ Not all keycodes below will work depending on which haptic mechanism you have ch
 | Name      | Description                                           |
 |-----------|-------------------------------------------------------|
 |`HPT_ON`   | Turn haptic feedback on                               |
-|`HPT_OFF`  | Turn haptic feedback on                               |
+|`HPT_OFF`  | Turn haptic feedback off                              |
 |`HPT_TOG`  | Toggle haptic feedback on/off                         |
 |`HPT_RST`  | Reset haptic feedback config to default               |
 |`HPT_FBK`  | Toggle feedback to occur on keypress, release or both |

docs/feature_oled_driver.md

@@ -229,6 +229,12 @@ void oled_write_P(const char *data, bool invert);
 // Remapped to call 'void oled_write_ln(const char *data, bool invert);' on ARM
 void oled_write_ln_P(const char *data, bool invert);
 
+// Writes a string to the buffer at current cursor position
+void oled_write_raw(const char *data, uint16_t size);
+
+// Writes a PROGMEM string to the buffer at current cursor position
+void oled_write_raw_P(const char *data, uint16_t size);
+
 // 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);

docs/fr-fr/_summary.md

@@ -1,33 +1,33 @@
 **En Français**
 
-* [Guide pour débutant complet](fr-FR/newbs.md)
-  * [Pour débuter](fr-FR/newbs_getting_started.md)
-  * [Compiler son premier firmware](fr-FR/newbs_building_firmware.md)
-  * [Flasher le Firmware](fr-FR/newbs_flashing.md)
-  * [Test et Débuggage](fr-FR/newbs_testing_debugging.md)
-  * [Bonnes pratiques Git](fr-FR/newbs_best_practices.md)
-  * [Ressources d'apprentissage](fr-FR/newbs_learn_more_resources.md)
+* [Guide pour débutant complet](fr-fr/newbs.md)
+  * [Pour débuter](fr-fr/newbs_getting_started.md)
+  * [Compiler son premier firmware](fr-fr/newbs_building_firmware.md)
+  * [Flasher le Firmware](fr-fr/newbs_flashing.md)
+  * [Test et Débuggage](fr-fr/newbs_testing_debugging.md)
+  * [Bonnes pratiques Git](fr-fr/newbs_best_practices.md)
+  * [Ressources d'apprentissage](fr-fr/newbs_learn_more_resources.md)
 
-* [Les bases de QMK](fr-FR/README.md)
-  * [Indroduction à QMK](fr-FR/getting_started_introduction.md)
-  * [QMK CLI](fr-FR/cli.md)
-  * [Configuration de la CLI QMK](fr-FR/cli_configuration.md)
-  * [Contribuer à QMK](fr-FR/contributing.md)
-  * [Comment utiliser GitHub](fr-FR/getting_started_github.md)
-  * [Trouver de l'aide](fr-FR/getting_started_getting_help.md)
+* [Les bases de QMK](fr-fr/README.md)
+  * [Indroduction à QMK](fr-fr/getting_started_introduction.md)
+  * [QMK CLI](fr-fr/cli.md)
+  * [Configuration de la CLI QMK](fr-fr/cli_configuration.md)
+  * [Contribuer à QMK](fr-fr/contributing.md)
+  * [Comment utiliser GitHub](fr-fr/getting_started_github.md)
+  * [Trouver de l'aide](fr-fr/getting_started_getting_help.md)
 
-* [Breaking changes](fr-FR/breaking_changes.md)
-  * [30 août 2019](fr-FR/ChangeLog/20190830.md)
+* [Breaking changes](fr-fr/breaking_changes.md)
+  * [30 août 2019](fr-fr/ChangeLog/20190830.md)
+
+* [FAQ](fr-fr/faq.md)
+  * [FAQ Générale](fr-fr/faq_general.md)
+  * [Compiler QMK](fr-fr/faq_build.md)
+  * [Débugguer / Dépanner QMK](fr-fr/faq_debug.md)
+  * [Keymap / Disposition](fr-fr/faq_keymap.md)
+  * [Installer les drivers avec Zadig](fr-fr/driver_installation_zadig.md)
 
 **En Anglais**
 
-* [FAQ](faq.md)
-  * [FAQ Générale](faq_general.md)
-  * [Compiler QMK](faq_build.md)
-  * [Débugguer / Dépanner QMK](faq_debug.md)
-  * [Keymap / Disposition](faq_keymap.md)
-  * [Installer les drivers avec Zadig](driver_installation_zadig.md)
-
 * Guides détaillés
   * [Installation des outils de compilation](getting_started_build_tools.md)
   * [Guide Vagrant](getting_started_vagrant.md)

docs/fr-fr/driver_installation_zadig.md

@@ -0,0 +1,46 @@
+# Installation du driver du bootloader avec Zadig
+
+Vous n’aurez pas besoin de pilote particulier pour utiliser un clavier QMK. En effet, QMK  se présente à l'ordinateur hôte comme un clavier HID standard et sera reconnu sans problème. Cependant vous aurez peut-être besoin d'un pilote pour flasher votre clavier avec Windows. En effet, quand vous redémarrerez votre clavier en mode bootloader, le périphérique que détectera Windows ne sera pas un clavier mais un périphérique bootloader.
+
+Il existe deux exceptions : le bootloader Caterina, qui se trouve en général sur les Pro Micros, et le bootloader Halfkay, livré avec les Teensy de PJRC. Ils apparaissent respectivement sous la forme d'un port série et d'un périphérique HID générique, ne nécessitant pas de pilote particulier.
+
+Nous vous recommandons d'utiliser l'utilitaire [Zadig](https://zadig.akeo.ie/). Si vous avez configuré votre environnement de développement avec Msys2 ou WSL, le script `qmk_install.sh` vous aura proposé l'installation des pilotes durant le processus.
+
+## Installation
+
+Passez votre clavier en mode bootloader, soit en appuyant sur le keycode `RESET` (qui peut se trouver dans un calque différent) ou en appuyant sur le bouton reset qui se trouve en général sous la board. Si votre clavier n'a aucune de ces options, essayez de le brancher en maintenant Escape ou Espace+`B` appuyés (voir la documentation de [Bootmagic](feature_bootmagic.md) pour plus de détails). Certaines boards utilisent [Command](feature_command.md) à la place de Bootmagic. Dans ce cas, vous pouvez entrer en mode bootloader en appuyant, à n'importe quel moment lorsque le clavier est branché, sur les combinaisons de touches Shift Gauche+Shift Droit+`B` ou Shift Gauche+Shift Droit+Escape.
+Certains claviers ont des instructions spécifiques pour passer en mode bootloader. Par exemple, la touche [Bootmagic Lite]](feature_bootmagic.md#bootmagic-lite) (défaut : Échap) peut être sur une touche différente telle que Contrôle Gauche. La combinaison pour la Command (défaut : Shift Gauche+Shift Droit) peut être différente, par exemple Contrôle Gauche+Contrôle Droit. Référez-vous au fichier README de votre clavier.
+
+Pour mettre un clavier en mode bootloader avec USBaspLoader, appuyez sur le bouton `RESET` tout en maintenant le bouton `BOOT`. Vous pouvez aussi maintenir le bouton `BOOT` en branchant le câble USB.
+
+Zadig détectera automatiquement les périphériques en mode bootloader. Il se peut toutefois que vous deviez vérifier en passant par  **Options → List All Devices**.
+
+
+ - Pour les claviers avec des MCUs Atmel AVR, le bootloader aura un nom similaire à `ATm32U4DFU`, et un Vendor ID `03EB`.
+ - Les bootloaders USBasp s'appelleront `USBasp`, avec un VID/PID `16C0:05DC`.
+ - Les claviers AVR flashé avec le bootloader QMK-DFU s'appelleront `<nom du clavier> Bootloader` et auront aussi le VID `03EB`.
+ - Pour la plupart des claviers ARM, ils s'appelleront `STM32 BOOTLOADER`, et auront un VID/PID `0483:DF11`.
+
+!> Si Zadig affiche certains de vos périphériques avec le driver `HidUsb`, votre clavier n'est probablement pas en mode bootloader. La flèche aura une couleur orange et vous aurez un message de confirmation vous demandant de modifier un pilote système. **Ne continuez pas!**
+
+Si la flèche apparaît en vert, sélectionnez le driver et appuyez sur le bouton **Install Driver**. Le driver `libusb-win32` devrait normalement fonctionner pour AVR, et `WinUSB` pour ARM. Si vous avez des problèmes pour flasher la board, essayez d'installer un pilote différent de la liste. Pour flasher un périphérique USBaspLoader en ligne de commande avec msys2, le driver `libusbk` est recommandé, sinon `libusb-win32` devrait fonctionner correctement si vous utilisez QMK Toolbox pour flasher.
+
+![Zadig montrant un driver de bootloader installé correctement](https://i.imgur.com/b8VgXzx.png)
+
+Finalement, débranchez et rebranchez le clavier afin de vous assurer que le nouveau pilote a bien été chargé. Si vous utilisez QMK Toolbox pour flasher, redémarrez-le aussi, il arrive qu'il n'arrive pas à détecter le changement de driver.
+
+## Récupérer l'installation du mauvais périphérique
+
+Si vous n'arrivez plus à saisir de texte avec le clavier, il est possible que vous ayez installé le driver sur le clavier au lieu du bootloader. Vous pouvez facilement vérifier ceci dans Zadig. Un clavier fonctionnel a le pilote `HidUsb` installé sur toutes ses interfaces :
+
+![Un clavier fonctionnel vu par Zadig](https://i.imgur.com/Hx0E5kC.png)
+
+Ouvrez le Gestionnaire de périphériques et cherchez un périphérique qui ressemble à votre clavier.
+
+![La board avec le mauvais driver installé, dans le Gestionnaire de périphériques](https://i.imgur.com/L3wvX8f.png)
+
+Cliquez dessus avec le bouton droit et sélectionner **Désinstaller le périphérique**. Faites bien attention à sélectionner **Supprimer le pilote pour ce périphérique** avant de valider.
+
+![Le dialogue Suppression de périphérique, avec la boîte "suppression de pilote" cochée](https://i.imgur.com/aEs2RuA.png)
+
+Appuyez sur **Action → Analyser les changements de hardware**. A ce stade, vous devriez pouvoir saisir à nouveau. Vérifiez dans Zadig que les périphériques utilisent bien le pilote `HidUsb`. Si c'est le cas, vous avez corrigé le problème, votre clavier devrait fonctionner à nouveau !

docs/fr-fr/faq.md

@@ -0,0 +1,6 @@
+# Foire Aux Questions
+
+* [FAQ Générale](faq_general.md)
+* [Construire ou Compiler QMK](faq_build.md)
+* [Débuguer et Dépanner QMK](faq_debug.md)
+* [Keymap (disposition)](faq_keymap.md)

docs/fr-fr/faq_build.md

@@ -0,0 +1,182 @@
+# Foire aux questions sur la compilation
+
+Cette page couvre les questions concernant la compilation de QMK. Si vous ne l'avez pas encore fait, vous devriez lire les guides [Configuration de l'environnement de build](getting_started_build_tools.md) et [Instructions pour Make](getting_started_make_guide.md).
+
+## Je ne peux pas programmer sous Linux
+
+Vous aurez besoin des permissions appropriées pour utiliser un périphérique. Pour les utilisateurs de Linux, référez-vous aux instructions concernant les règles `udev` ci-dessous. Si `udev` vous pose des problèmes, une alternative est d'utiliser la commande `sudo`. Si vous ne connaissez pas cette commande, référez-vous à son manuel d'utilisation en utilisant `man sudo` ou [regardez cette page](https://linux.die.net/man/8/sudo).
+
+Un exemple utilisant `sudo`, lorsque votre contrôleur est un ATMega32u4 :
+
+    $ sudo dfu-programmer atmega32u4 erase --force
+    $ sudo dfu-programmer atmega32u4 flash your.hex
+    $ sudo dfu-programmer atmega32u4 reset
+
+ou simplement :
+
+    $ sudo make <keyboard>:<keymap>:dfu
+
+Veuillez noter que lancer `make` avec `sudo` est généralement une **mauvaise** idée, et vous devriez préférer une des méthodes précédente, si possible.
+
+### Règles `udev` pour Linux
+
+Sous Linux, vous aurez besoin des permissions appropriées pour accéder au MCU (le micro-contrôleur). Vous avez le choix d'utiliser `sudo` en flashant le firmware, ou placer ces fichiers dans `/etc/udev/rules.d`. Une fois ajouté, lancez les commandes suivantes :
+
+```console
+sudo udevadm control --reload-rules
+sudo udevadm trigger
+```
+
+**/etc/udev/rules.d/50-atmel-dfu.rules:**
+```
+# Atmel ATMega32U4
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="03eb", ATTRS{idProduct}=="2ff4", MODE:="0666"
+# Atmel USBKEY AT90USB1287
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="03eb", ATTRS{idProduct}=="2ffb", MODE:="0666"
+# Atmel ATMega32U2
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="03eb", ATTRS{idProduct}=="2ff0", MODE:="0666"
+```
+
+**/etc/udev/rules.d/52-tmk-keyboard.rules:**
+```
+# tmk keyboard products     https://github.com/tmk/tmk_keyboard
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="feed", MODE:="0666"
+```
+
+**/etc/udev/rules.d/54-input-club-keyboard.rules:**
+
+```
+# Input Club keyboard bootloader
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="1c11", MODE:="0666"
+```
+
+**/etc/udev/rules.d/55-catalina.rules:**
+```
+# ModemManager should ignore the following devices
+ATTRS{idVendor}=="2a03", ENV{ID_MM_DEVICE_IGNORE}="1"
+ATTRS{idVendor}=="2341", ENV{ID_MM_DEVICE_IGNORE}="1"
+```
+
+**Note:** Le filtrage utilisant ModemManager fonctionnera uniquement si vous n'êtes pas en mode strict. Les commandes suivantes peuvent changer cette option :
+
+```console
+sudo sed -i 's/--filter-policy=strict/--filter-policy=default/' /lib/systemd/system/ModemManager.service
+sudo systemctl daemon-reload
+sudo systemctl restart ModemManager
+```
+
+**/etc/udev/rules.d/56-dfu-util.rules:**
+
+```
+# stm32duino
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="1eaf", ATTRS{idProduct}=="0003", MODE:="0666"
+# Generic stm32
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="df11", MODE:="0666"
+```
+
+### Le périphérique sériel n'est pas détecté en mode bootloader sous Linux
+
+Assurez-vous que votre kernel ait un support approprié pour votre périphérique. Si votre périphérique utilise USB ACM, par exemple pour les Pro Micro (AtMega32u4), assurez-vous d'inclure `CONFIG_USB_ACM=y`. D'autres périphériques peuvent avoir besoin de `USB_SERIAL` et de ses sous-options.
+
+## Périphérique inconnu pour le bootloader DFU
+
+Les problèmes rencontrés lorsque l'on flash des claviers sous Windows sont, la plupart du temps, dus à une installation du mauvais pilote, ou un pilote manquant.
+
+Relancer le script d'installation de QMK (`./util/qmk_install.sh` situé dans répertoire `qmk_firmware`sous MSYS2 ou WSL) ou réinstaller la QMK Toolbox peut résoudre le problème. Une alternative est de télécharger et lancer manuellement le package [`qmk_driver_installer`](https://github.com/qmk/qmk_driver_installer).
+
+Si vous rencontrez toujours des problèmes, essayez de télécharger et lancer Zadig. Voir [Installation du driver du bootloader avec Zadig](driver_installation_zadig.md) pour plus d'informations.
+
+## WINAVR est obsolète
+
+Il n'est plus recommandé et peut causer des problèmes. Voir [TMK Issue #99](https://github.com/tmk/tmk_keyboard/issues/99).
+
+## USB VID et PID
+
+Vous pouvez utiliser l'ID de votre choix en modifier `config.h`. Il y a peu de chance de conflit avec d'autres produits.
+
+La plupart des boards QMK utilisent `0xFEED` comme vendor ID. Vérifiez les autres claviers pour être sûr de choisir un Product ID unique.
+
+Étudiez aussi ce ticket
+https://github.com/tmk/tmk_keyboard/issues/150
+
+Vous pouvez acheter un VID:PID unique ici. Je ne pense pas que ce soit nécessaire pour un usage personnel.
+- http://www.obdev.at/products/vusb/license.html
+- http://www.mcselec.com/index.php?page=shop.product_details&flypage=shop.flypage&product_id=92&option=com_phpshop&Itemid=1
+
+## Cortex: `cstddef: No such file or directory`
+
+Ce problème existait avec le GCC 4.8 d'Ubuntu 14.04, la solution a nécessité de mettre à jour vers 4.9 avec ce PPA.
+https://launchpad.net/~terry.guo/+archive/ubuntu/gcc-arm-embedded
+
+https://github.com/tmk/tmk_keyboard/issues/212
+https://github.com/tmk/tmk_keyboard/wiki/mbed-cortex-porting#compile-error-cstddef
+https://developer.mbed.org/forum/mbed/topic/5205/
+
+## `clock_prescale_set` and `clock_div_1` Not Available
+
+Votre chaîne d'outils (Toolchain) est trop vieille pour supporter le MCU. Par exemple, WinAVR 20100110 ne supporte pas ATMega32u2.
+
+```
+Compiling C: ../../tmk_core/protocol/lufa/lufa.c
+avr-gcc -c -mmcu=atmega32u2 -gdwarf-2 -DF_CPU=16000000UL -DINTERRUPT_CONTROL_ENDPOINT -DBOOTLOADER_SIZE=4096 -DF_USB=16000000UL -DARCH=ARCH_AVR8 -DUSB_DEVICE_ONLY -DUSE_FLASH_DESCRIPTORS -DUSE_STATIC_OPTIONS="(USB_DEVICE_OPT_FULLSPEED | USB_OPT_REG_ENABLED | USB_OPT_AUTO_PLL)" -DFIXED_CONTROL_ENDPOINT_SIZE=8  -DFIXED_NUM_CONFIGURATIONS=1 -DPROTOCOL_LUFA -DEXTRAKEY_ENABLE -DCONSOLE_ENABLE -DCOMMAND_ENABLE -DVERSION=unknown -Os -funsigned-char -funsigned-bitfields -ffunction-sections -fdata-sections -fno-inline-small-functions -fpack-struct -fshort-enums -fno-strict-aliasing -Wall -Wstrict-prototypes -Wa,-adhlns=obj_alps64/protocol/lufa/lufa.lst -I. -I../../tmk_core -I../../tmk_core/protocol/lufa -I../../tmk_core/protocol/lufa/LUFA-git -I../../tmk_core/common -std=gnu99 -include config.h -MMD -MP -MF .dep/obj_alps64_protocol_lufa_lufa.o.d  ../../tmk_core/protocol/lufa/lufa.c -o obj_alps64/protocol/lufa/lufa.o
+../../tmk_core/protocol/lufa/lufa.c: In function 'setup_mcu':
+../../tmk_core/protocol/lufa/lufa.c:575: warning: implicit declaration of function 'clock_prescale_set'
+../../tmk_core/protocol/lufa/lufa.c:575: error: 'clock_div_1' undeclared (first use in this function)
+../../tmk_core/protocol/lufa/lufa.c:575: error: (Each undeclared identifier is reported only once
+../../tmk_core/protocol/lufa/lufa.c:575: error: for each function it appears in.)
+make: *** [obj_alps64/protocol/lufa/lufa.o] Error 1
+```
+
+## BOOTLOADER_SIZE pour AVR
+
+Notez que la taille du bootloader pour les Teensy2.0++ est de 2048bytes. Quelques Makefiles peuvent contenir une erreur et avoir le mauvais commentaire.
+
+```
+# Boot Section Size in *bytes*
+#   Teensy halfKay   512
+#   Teensy++ halfKay 2048
+#   Atmel DFU loader 4096       (TMK Alt Controller)
+#   LUFA bootloader  4096
+#   USBaspLoader     2048
+OPT_DEFS += -DBOOTLOADER_SIZE=2048
+```
+
+## `avr-gcc: internal compiler error: Abort trap: 6 (program cc1)` sous MacOS
+
+C'est un problème de mise à jour avec brew, causée par des liens symboliques (symlinks) dont dépend avr-gcc qui sont détruits.
+
+La solution est de supprimer et réinstaller tous les modules affectés.
+
+```
+brew rm avr-gcc
+brew rm dfu-programmer
+brew rm dfu-util
+brew rm gcc-arm-none-eabi
+brew rm avrdude
+brew install avr-gcc
+brew install dfu-programmer
+brew install dfu-util
+brew install gcc-arm-none-eabi
+brew install avrdude
+```
+
+### avr-gcc 8.1 et LUFA
+
+Si vous avez mis à jour votre avr-gcc au-dessus de la version 7, vous risquez de voir des erreurs impliquant LUA. Par exemple :
+
+`lib/lufa/LUFA/Drivers/USB/Class/Device/AudioClassDevice.h:380:5: error: 'const' attribute on function returning 'void'`
+
+Pour le moment, vous devrez revenir à la version 7 de avr-gcc dans brew.
+
+```
+brew uninstall --force avr-gcc
+brew install avr-gcc@8
+brew link --force avr-gcc@8
+```
+
+### Je viens de flasher mon clavier et il ne fait rien/l'appui des touches n'est pas enregistré - c'est aussi un ARM(rev6 plank, clueboard 60, hs60v2, etc.) (Février 2019)
+
+A cause de la manière dont les EEPROM fonctionnent sur les puces ARM, les options sauvegardées peuvent ne plus être valides. Ceci affecte les calques par défaut et *peut*, sous certaines conditions que nous essayons encore de déterminer, rendre le clavier inutilisable. Réinitialiser l'EEPROM corrigera le problème.
+
+[Réinitialiser EEPROM sur Planck rev6](https://cdn.discordapp.com/attachments/473506116718952450/539284620861243409/planck_rev6_default.bin) peut être utilisé pour forcer une réinitialisation d'EEPROM. Une fois cette image flashée, flashez à nouveau votre firmware standard. Cela devrait rétablir le fonctionnement de votre clavier.
+Si bootmagic est activé dans n'importe quel forme, vous devriez être capable de faire aussi ceci (regardez  [Documentation Bootmagic](feature_bootmagic.md) et les informations spécifiques à votre clavier).

docs/fr-fr/faq_debug.md

@@ -0,0 +1,236 @@
+# FAQ Débugage
+
+Cette page détaille diverses questions fréquemment posées par les utilisateurs sur le dépannage de leurs claviers.
+
+# Console de débugage
+
+## `hid_listen` ne reconnaît pas de périphérique
+
+Lorsque la console de débugage sur votre périphérique n'est pas prêt, vous obtiendrez un message similaire :
+
+```
+Waiting for device:.........
+```
+
+Une fois le périphérique connecté, *hid_listen* le trouve et vous obtiendrez ce message :
+
+```
+Waiting for new device:.........................
+Listening:
+```
+
+Si vous ne recevez pas ce message `Listening:`, essayez de compiler avec `CONSOLE_ENABLE=yes` dans le [Makefile]
+
+Il se peut que vous ayez besoin de certains privilèges avancés pour accéder à des périphériques sur des OS comme Linux.
+
+- Essayez `sudo hid_listen`
+
+## Ne reçoit pas de messages sur la console
+
+Vérifiez :
+
+- *hid_listen* trouve votre périphérique. Voir ci-dessus.
+- Activez le débugage en appuyant sur **Magic**+d. Voir [Commandes Magic](https://github.com/tmk/tmk_keyboard#magic-commands).
+- Définissez `debug_enable=true` en général dans `matrix_init()` du fichier **matrix.c**.
+- Essayez d'utiliser la fonction `print` à la place du debug print. Voir **common/print.h**.
+- Déconnectez tous les autres périphériques qui utilisent la fonction console. Voir [Issue #97](https://github.com/tmk/tmk_keyboard/issues/97).
+
+## Linux ou les systèmes UNIX nécessitent des privilèges super utilisateur
+
+Utilisez `sudo` pour exécuter *hid_listen* avec des privilèges étendus.
+
+```
+$ sudo hid_listen
+```
+
+Ou ajoutez une *udev rule* pour les périphériques TMK en plaçant un fichier dans le répertoire rules. Le chemin vers ce répertoire peut varier en fonction du système.
+
+Fichier: /etc/udev/rules.d/52-tmk-keyboard.rules(sous Ubuntu)
+```
+# tmk keyboard products     https://github.com/tmk/tmk_keyboard
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="feed", MODE:="0666"
+```
+
+***
+
+# Divers
+
+## Considérations de sécurité
+
+Vous ne voulez probablement pas "briquer" votre clavier, rendre impossible d'écrire un firmware dessus. Il y a quelques paramètres qui montrent ce qui est (et n'est probablement pas) trop risqué.
+
+- Si votre map de clavier n'inclut pas de RESET, pour entrer en mode DFU, vous devrez appuyer sur le bouton reset du PCB. Cela implique que vous devrez certainement dévisser certaines pièces de votre clavier pour y accéder.
+- Modifier les fichiers tmk_core / common peut rendre le clavier inutilisable
+- Si un fichier .hex trop large est la cause du problème : `make dfu` supprime le bloc puis teste la taille (il ne fait pas les choses dans le bon ordre), ce qui provoque une erreur. En résultat, le flash n’aura pas été fait et le clavier restera en mode DFU.
+- Pour finir, notez que la taille maximale d'un fichier .hex sur un Plank est de 7000h (28672 decimal)
+
+```
+Linking: .build/planck_rev4_cbbrowne.elf                                                            [OK]
+Creating load file for Flash: .build/planck_rev4_cbbrowne.hex                                       [OK]
+
+Size after:
+   text    data     bss     dec     hex filename
+      0   22396       0   22396    577c planck_rev4_cbbrowne.hex
+```
+
+- La taille du fichier ci-dessus est de 22396/577ch, ce qui est en dessous de 28672/7000h
+- Tant que vous avez un fichier .hex alternatif correct, vous pouvez réessayer en le chargeant
+- Certaines options que vous pouvez spécifier dans votre Makefile consomme de la mémoire supplémentaire. Faites attention aux options BOOTMAGIC_ENABLE, MOUSEKEY_ENABLE, EXTRAKEY_ENABLE, CONSOLE_ENABLE, API_SYSEX_ENABLE.
+- Les outils DFU **ne** vous permettent **pas** d'écrire dans le bootloader (à moins que vous n'ajoutiez des options spéciales), il n'y a donc peu de risque.
+- Les EEPROM ont environ 100000 cycles d'écriture. Ne réécrivez pas le firmware de manière continue et répétée. Vous allez détruire définitivement l'EEPROM.
+
+## NKRO ne fonctionne pas
+
+Premièrement, vous devez compiler le firmware avec l'option de compilation `NKRO_ENABLE` dans le **Makefile**.
+
+Essayez la commande `Magic` **N** (`LShift+RShift+N` par défaut) si **NKRO** ne fonctionne toujours pas. Vous pouvez utiliser cette commande pour basculer temporairement entre le mode **NKRO** et **6KRO**. Sous certaines conditions, **NKRO** ne fonctionnera pas et vous devrez basculer en **6KRO**, en particulier lorsque vous êtes dans le BIOS.
+
+Si votre firmware est compilé avec `BOOTMAGIC_ENABLE` vous devrez l'activer avec la commande `BootMagic` **N** (`Espace+N` par défaut). Cette option est enregistrée dans l'EEPROM et sera gardé entre deux cycles de démarrage.
+
+https://github.com/tmk/tmk_keyboard#boot-magic-configuration---virtual-dip-switch
+
+## Le TrackPoint a besoin Circuit de réinitialisation (Support de souris PS/2)
+
+Sans circuit de réinitialisation vous allez avoir des résultats inconsistants à cause de la mauvaise initialisation du matériel. Regardez le schéma du circuit du TPM754.
+
+- http://geekhack.org/index.php?topic=50176.msg1127447#msg1127447
+- http://www.mikrocontroller.net/attachment/52583/tpm754.pdf
+
+## Impossible de lire la colonne de la matrice après 16
+
+Utilisez `1UL<<16` à la place de `1<<16` dans `read_cols()` du fichier [matrix.h] lorsque le nombre de vos colonnes dépassent 16.
+
+En C, `1` implique un type [int] qui est [16 bits] pour les AVR, ce qui implique que vous ne pouvez pas décaler à gauche de plus de 15. Si vous utilisez `1<<16`, vous aurez un résultat non attendu de zéro. Vous devez donc utiliser un type [unsigned long] en utilisant `1UL`.
+
+http://deskthority.net/workshop-f7/rebuilding-and-redesigning-a-classic-thinkpad-keyboard-t6181-60.html#p146279
+
+## Bootloader Jump ne fonctionne pas
+
+Configurez correctement la taille du bootloader dans le **Makefile**. Une mauvaise taille de section du bootloader empêchera probablement le démarrage avec **Magic command** et **Boot Magic**.
+
+```
+# Size of Bootloaders in bytes:
+#   Atmel DFU loader(ATmega32U4)   4096
+#   Atmel DFU loader(AT90USB128)   8192
+#   LUFA bootloader(ATmega32U4)    4096
+#   Arduino Caterina(ATmega32U4)   4096
+#   USBaspLoader(ATmega***)        2048
+#   Teensy   halfKay(ATmega32U4)   512
+#   Teensy++ halfKay(AT90USB128)   2048
+OPT_DEFS += -DBOOTLOADER_SIZE=4096
+```
+
+La taille de la section de démarrage de AVR est définie par l'option **BOOTSZ** fuse. Vérifiez la fiche technique du MCU. Veuilez noter que les tailles et adresses sont définies en **Word** (2 octets) dans la fiche technique alors que TMK utilise des **Byte**.
+
+La section de boot AVR se trouve à la fin de la mémoire flash, comme suit.
+
+```
+byte     Atmel/LUFA(ATMega32u4)          byte     Atmel(AT90SUB1286)
+0x0000   +---------------+               0x00000  +---------------+
+         |               |                        |               |
+         |               |                        |               |
+         |  Application  |                        |  Application  |
+         |               |                        |               |
+         =               =                        =               =
+         |               | 32KB-4KB               |               | 128KB-8KB
+0x6000   +---------------+               0x1E000  +---------------+
+         |  Bootloader   | 4KB                    |  Bootloader   | 8KB
+0x7FFF   +---------------+               0x1FFFF  +---------------+
+
+
+byte     Teensy(ATMega32u4)              byte     Teensy++(AT90SUB1286)
+0x0000   +---------------+               0x00000  +---------------+
+         |               |                        |               |
+         |               |                        |               |
+         |  Application  |                        |  Application  |
+         |               |                        |               |
+         =               =                        =               =
+         |               | 32KB-512B              |               | 128KB-2KB
+0x7E00   +---------------+               0x1FC00  +---------------+
+         |  Bootloader   | 512B                   |  Bootloader   | 2KB
+0x7FFF   +---------------+               0x1FFFF  +---------------+
+```
+
+Référez-vous à cette discussion pour plus de référence.
+https://github.com/tmk/tmk_keyboard/issues/179
+
+Si vous utilisez un TeensyUSB, il y a un [bug connu](https://github.com/qmk/qmk_firmware/issues/164) qui fait que le bouton reset matériel empêche la touche RESET de fonctionner. Débrancher et rebrancher le clavier devrait résoudre le problème.
+
+## Les touches spéciales ne fonctionnent pas (Touche Système, Touches de contrôle du son)
+
+Vous devez définir `EXTRAKEY_ENABLE` dans le fichier `rules.mk` pour les utiliser dans QMK.
+
+```
+EXTRAKEY_ENABLE = yes          # Audio control and System control
+```
+
+## Réveiller du mode veille ne fonctionne pas
+
+Sous Windows, activez l'option `Permettre au périphérique de sortir l'ordinateur de veille` dans les paramètres des **Options d'alimentations** du **Gestionnaire de périphériques**. Vérifiez aussi les paramètres du BIOS.
+
+Appuyer sur n'importe quelle touche en mode veille devrait sortir l'ordinateur de veille.
+
+## Vous utilisez un Arduino ?
+
+**Faites attention au fait que le nommage des pin d'un Arduino diffère de la puce**. Par exemple, la pin `D0` n'est pas `PD0`. Vérifiez le circuit avec la fiche technique.
+
+- http://arduino.cc/en/uploads/Main/arduino-leonardo-schematic_3b.pdf
+- http://arduino.cc/en/uploads/Main/arduino-micro-schematic.pdf
+
+Les Arduino Leonardo et micro ont des **ATMega32U4** et peuvent être utilisés avec TMK, mais le bootloader Arduino peut causer des problèmes.
+
+## Activer JTAG
+
+Par défaut, le débugage des interfaces JTAG est désactivé dès que le clavier démarre. Les MCUs compatible JTAG viennent d'usine avec le fusible `JTAGEN` activé, et il prend certaines pins du MCU que la board pourrait utiliser pour la matrice, les LEDs, etc.
+
+Si vous voulez garder JTAG activé, ajoutez la ligne suivante à votre fichier `config.h` :
+
+```c
+#define NO_JTAG_DISABLE
+```
+
+## Adding LED Indicators of Lock Keys
+
+Si vous souhaitez votre propre indicateur LED pour CapsLock, ScrollLock et NumLock alors lisez ce post.
+
+http://deskthority.net/workshop-f7/tmk-keyboard-firmware-collection-t4478-120.html#p191560
+
+## Programmer Arduino Micro/Leonardo
+
+Appuyez sur le bouton reset puis lancez la commande suivante dans les 8 secondes.
+
+```
+avrdude -patmega32u4 -cavr109 -b57600 -Uflash:w:adb_usb.hex -P/dev/ttyACM0
+```
+
+Le nom du périphérique peut varier en fonction de votre système.
+
+http://arduino.cc/en/Main/ArduinoBoardMicro
+https://geekhack.org/index.php?topic=14290.msg1563867#msg1563867
+
+## Compatibilité USB 3
+
+Il semble que certaines personnes ont eu des problèmes avec les ports USB 3, essayez un port USB 2.
+
+## Compatibilité Mac
+
+### OS X 10.11 et Hub
+
+https://geekhack.org/index.php?topic=14290.msg1884034#msg1884034
+
+## Problème sur BIOS (UEFI) / Resume (Mise en veille et réveil) / Redémarrage
+
+Certaines personnes ont eu des problèmes de fonctionnement de leur clavier dans le BIOS et/ou après des redémarrages.
+
+Pour le moment, l'origine du problème n'est pas comprise, mais certaines options de compilation semble liées. Dans le Makefile, essayez de désactiver les options comme  `CONSOLE_ENABLE`, `NKRO_ENABLE`, `SLEEP_LED_ENABLE` et/ou d'autres.
+
+https://github.com/tmk/tmk_keyboard/issues/266
+https://geekhack.org/index.php?topic=41989.msg1967778#msg1967778
+
+## FLIP ne marche pas
+
+### `AtLibUsbDfu.dll` Not Found
+
+Supprimez le pilote actuel et réinstallez celui donné par FLIP dans le gestionnaire de périphériques.
+
+http://imgur.com/a/bnwzy

docs/fr-fr/faq_general.md

@@ -0,0 +1,16 @@
+# Questions fréquemment posées
+
+## Qu'est-ce que QMK ?
+
+[QMK](https://github.com/qmk), acronyme pour Quantum Mechanical Keyboard, est un groupe de personnes qui construisent des outils pour des claviers personnalisés. Nous avons commencé par le [firmware QMK](https://github.com/qmk/qmk_firmware), un fork très modifié du firmware [TMK](https://github.com/tmk/tmk_keyboard).
+
+## Quelles sont les différences entre QMK et TMK ?
+
+TMK a été conçu et développé à l'origine par [Jun Wako](https://github.com/tmk). QMK a démarré comme étant le fork de [Jack Humbert](https://github.com/jackhumbert) pour le Planck. Au bout d'un moment, le fork de Jack a divergé de manière significative de TMK et, en 2015, Jack a décidé de le renommer QMK.
+
+D'un point de vue technique, QMK se base sur TMK en lui ajoutant plusieurs nouvelles fonctionnalités.
+QMK a notamment augmenté le nombre de keycodes disponibles et les a utilisé pour implémenter des fonctionnalités avancées telles que `S()`, `LCTL()` et `MO()`. Vous pouvez voir une liste complète de ces keycodes dans [Keycodes] (keycodes.md).
+
+D'un point de vue management de projet et communauté, Hasu, sur TMK maintient tous les claviers supportés officiellement par lui-même, avec un peu de support de la communauté. Il existe ou peuvent être créées d'autres communautés maintenant des fork pour d'autres claviers. Peu de keymaps sont définies par défaut, les utilisateurs ne se partagent donc pas leurs keymaps en général. QMK encourage le partage des claviers et des keymaps à l'aide d'un dépôt géré de manière centrale, acceptant les pull requests qui suivent les standards de qualité. Ceux-ci sont surtout maitenus par la communauté, mais l'équipe de QMK aide aussi lorsque c'est nécessaire.
+
+Les deux approches ont leurs avantages et leurs inconvénients, et le développements de fonctionnalités intéressantes sont partagées entre TMK et QMK lorsque fait sens.

docs/fr-fr/faq_keymap.md

@@ -0,0 +1,226 @@
+# FAQ Keymap
+
+Cette page couvre les questions souvent posées à propos des keymaps. Si vous ne l'avez pas encore fait, vous devriez commencer par là [Aperçu des Keymap](keymap.md).
+
+## Quels Keycodes puis-je utiliser ?
+
+Regardez [Keycodes](keycodes.md) pour une liste des keycodes disponibles. Certains keycodes spécifiques ont des documentations plus complètes de disponible.
+
+Les keycodes sont définies dans [common/keycode.h](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/keycode.h).
+
+## Quels sont les keycodes par défaut ?
+
+Il existe 3 configurations de clavier standard utilisées dans le monde: ANSI, ISO et JIS. L'Amérique du Nord utilise principalement l'ANSI, l'Europe et l'Afrique l'ISO et le Japon utilise JIS. Les autres régions utilisent généralement ANSI ou ISO. Les keycodes correspondant à ces dispositions spécifiques sont affichés ici :
+
+<!-- Source for this image: http://www.keyboard-layout-editor.com/#/gists/bf431647d1001cff5eff20ae55621e9a -->
+![Keyboard Layout Image](https://i.imgur.com/5wsh5wM.png)
+
+## Certaines de mes touches sont permutées ou ne fonctionnent pas
+
+QMK possède deux fonctionnalités, Bootmagic et Command, qui vous permettent de modifier le comportement de votre clavier à la volée. Cela inclut, sans toutefois s'y limiter, l'échange de Ctrl / Majuscules, la désactivation de l'interface graphique, le basculement de Alt/Gui, le basculement de barre d'espacement arrière/barre oblique inversée, la désactivation de toutes les touches et d'autres modifications comportementales.
+
+Pour résoudre rapidement le problème, essayez de maintenir les touches Espace + Retour arrière enfoncées pendant que vous branchez votre clavier. Cela réinitialisera les paramètres stockés sur votre clavier, ramenant ces touches à un fonctionnement normal. Si cela ne fonctionne pas, regardez ici:
+
+* [Bootmagic](feature_bootmagic.md)
+* [Command](feature_command.md)
+
+## La touche de menu ne fonctionne pas
+
+La touche trouvée sur la plupart des claviers modernes située entre `KC_RGUI` et` KC_RCTL` est en réalité appelée `KC_APP`. En effet, lorsque cette touche a été inventée, il existait déjà une clé nommée `MENU` dans les normes correspondantes. MS a donc choisi de l'appeler la touche` APP`.
+
+## `KC_SYSREQ` ne fonctionne pas
+
+Utilisez le keycode pour Print Screen (`KC_PSCREEN` or `KC_PSCR`) à la place de `KC_SYSREQ`. La combinaison de touche 'Alt + Print Screen' est reconnue comme 'System request'.
+
+Voir [issue #168](https://github.com/tmk/tmk_keyboard/issues/168) et
+* http://en.wikipedia.org/wiki/Magic_SysRq_key
+* http://en.wikipedia.org/wiki/System_request
+
+## Les touches alimentation ne fonctionnent pas
+
+Un peu déroutant, il y a deux codes de touche "Alimentation" dans QMK: `KC_POWER` dans la page d'utilisation du clavier / keypad, et `KC_SYSTEM_POWER` (ou `KC_PWR`) dans la page Consumer.
+
+Le premier n'est reconnu que sur macOS, alors que le dernier, `KC_SLEP` et `KC_WAKE` sont supportés par les trois principaux systèmes d'exploitation. Il est donc recommandé de les utiliser à la place. Sous Windows, ces touches prennent effet immédiatement, mais sur macOS, elles doivent être maintenues enfoncées jusqu'à ce qu'une boîte de dialogue apparaisse.
+
+## Modificateur "One Shot"
+
+Cette fonctionnalité permet de corriger un problème avec la touche Shift. En effet, il arrive de saisir plusieurs majuscules en ne voulant en saisir qu'une sur un mot. Ex : `CEtte` à la place de `Cette`. La fonctionnalité « One shot » shift permet de corriger ça.
+
+https://github.com/tmk/tmk_keyboard/issues/67
+
+## Le modificateur d'un calque reste bloqué
+
+Les touches de modification ou les calques peuvent être bloquées si la commutation de calque n'est pas configurée correctement.
+Pour les touches de modification et les actions de calque, vous devez placer `KC_TRANS` sur la même position du calque de destination afin de désenregistrer la clé de modificateur ou de revenir au calque précédent lors de la libération.
+
+* https://github.com/tmk/tmk_core/blob/master/doc/keymap.md#31-momentary-switching
+* http://geekhack.org/index.php?topic=57008.msg1492604#msg1492604
+* https://github.com/tmk/tmk_keyboard/issues/248
+
+## Support de touche à verrouillage mécanique
+
+Cette fonctionnalité permet l'usage de *touches à verrouillage mécanique* comme [ces interrupteurs Alps](http://deskthority.net/wiki/Alps_SKCL_Lock). Vous pouvez l'activer en ajoutant ceci à votre `config.h` :
+
+```
+#define LOCKING_SUPPORT_ENABLE
+#define LOCKING_RESYNC_ENABLE
+```
+
+Une fois la fonction activée, utilisez les keycodes `KC_LCAP`, `KC_LNUM` et `KC_LSCR` dans votre keymap.
+
+Des vieux claviers mécaniques ont parfois des touches à verrouillage, mais les claviers modernes n'en sont pas équipés. ***Vous n'avez pas besoin de cette fonction dans la majorité des cas et devez utiliser les keycodes `KC_CAPS`, `KC_NLCK` et `KC_SLCK`.***
+
+## Ajouter des caractères spéciaux autres que ASCII comme la cédille 'Ç'
+
+IL N'EXISTE AUCUNE METHODE UNIVERSELLE POUR LES AJOUTER QUI FONCTIONNE SUR TOUS LES SYSTEMES. Vous devez définir une **MACRO** d'une manière spécifique à votre OS ou layout.
+
+Voir ce post pour un exemple de code **MACRO**.
+
+http://deskthority.net/workshop-f7/tmk-keyboard-firmware-collection-t4478-120.html#p195620
+
+Sous **Windows** vous pouvez utiliser la touche `AltGr` ou **Alt code**.
+* http://en.wikipedia.org/wiki/AltGr_key
+* http://en.wikipedia.org/wiki/Alt_code
+
+Sous **Mac OS** définissez une combinaison de touche `Option`.
+* http://en.wikipedia.org/wiki/Option_key#Alternative_keyboard_input
+
+Sous **Xorg** vous pouvez utiliser une touche `compose` à la place.
+* http://en.wikipedia.org/wiki/Compose_key
+
+Et voir ceci pour une entrée **Unicode**.
+* http://en.wikipedia.org/wiki/Unicode_input
+
+## Touche `Fn` sur macOS
+
+Contrairement à la plupart des touches Fn, celle des claviers Apple a son propre code d'activation... en quelque sorte. Il remplace le sixième code d'activation dans un rapport de base 6KRO HID - de sorte qu'un clavier Apple ne contient en réalité que 5KRO.
+
+Il est techniquement possible de demander à QMK d’envoyer ce keycode. Cependant, cela nécessite une modification du format du rapport pour ajouter l'état de la touche Fn.
+Pire encore, ce keycode n'est reconnu que si les identifiants du clavier VID et PID correspondent à ceux d'un vrai clavier Apple. Malheureusement QMK ne peut juridiquement prendre en charge cette fonctionnalité et il y a peu de chance que la situation s'améliore.
+
+Voir [cette issue](https://github.com/qmk/qmk_firmware/issues/2179) pour des informations détaillées.
+
+## Touches Media sous Mac OSX
+
+#### KC_MNXT et KC_MPRV ne fonctionnent pas sous Mac
+
+Utilisez `KC_MFFD`(`KC_MEDIA_FAST_FORWARD`) et `KC_MRWD`(`KC_MEDIA_REWIND`) à la place de `KC_MNXT` et `KC_MPRV`.
+Voir https://github.com/tmk/tmk_keyboard/issues/195
+
+## Touches supportées sous Mac OSX?
+
+Vous pouvez connaître les keycodes supportés par OSX en lisant ce code source.
+
+`usb_2_adb_keymap` contient les tableaux des pages Keyboard/Keypad vers les scancodes ADB (keycodes interne à OSX).
+
+https://opensource.apple.com/source/IOHIDFamily/IOHIDFamily-606.1.7/IOHIDFamily/Cosmo_USB2ADB.c
+
+Et `IOHIDConsumer::dispatchConsumerEvent` s'occupe des utilisations Consumer page.
+
+https://opensource.apple.com/source/IOHIDFamily/IOHIDFamily-606.1.7/IOHIDFamily/IOHIDConsumer.cpp
+
+## Touches JIS dans Mac OSX
+
+Les touches de clavier spécifiques JIS comme `無変換(Muhenkan)`, `変換(Henkan)`, `ひらがな(hiragana)` ne sont pas reconnues par OSX. Vous pouvez utiliser **Seil** pour les activer, esssayez les options suivantes.
+
+* Activer la touche NFER sur clavier PC
+* Activer la touche XFER sur clavier PC
+* Activer la touche KATAKANA sur clavier PC
+
+https://pqrs.org/osx/karabiner/seil.html
+
+## RN-42 Bluetooth ne fonctionne pas avec Karabiner
+
+Karabiner - Outil de Keymapping sous Mac OSX - Ignore les entrées du module RN-42. Vous devez activer cette option pour rendre Karabiner compatible avec votre clavier.
+https://github.com/tekezo/Karabiner/issues/403#issuecomment-102559237
+
+Plus de détails sur ce problème sur les liens suivants.
+https://github.com/tmk/tmk_keyboard/issues/213
+https://github.com/tekezo/Karabiner/issues/403
+
+## Esc et <code>&#96;</code> sur une touche simple.
+
+Cette fonctionnalité permet d'utiliser une touche à la fois comme touche Échap ou une touche  `§` (En Azerty) selon le cas d’utilisation. Cela est très utile sur un clavier de petite taille.
+
+Voir la fonctionnalité [Grave Escape](feature_grave_esc.md).
+
+## Avoir les touches modificatrices qui ont double usage en flèches directionnelles.
+
+Ceci transforme les touches "modificateur droit" en touches fléchées lorsque les touches sont seulement "tapées" tout en restant des modificateurs lorsqu'elles sont maintenues.
+
+Dans TMK la fonction double rôle s'appelle **TAP**.
+
+```C
+
+#include "keymap_common.h"
+
+
+/* Arrow keys on right modifier keys with TMK dual role feature
+ *
+ *  https://github.com/tmk/tmk_core/blob/master/doc/keymap.md#213-modifier-with-tap-keydual-role
+ *  https://en.wikipedia.org/wiki/Modifier_key#Dual-role_keys
+ */
+const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    /* 0: qwerty */
+    [0] = LAYOUT( \
+        ESC, 1,   2,   3,   4,   5,   6,   7,   8,   9,   0,   MINS,EQL, NUHS,BSPC, \
+        TAB, Q,   W,   E,   R,   T,   Y,   U,   I,   O,   P,   LBRC,RBRC,BSLS, \
+        LCTL,A,   S,   D,   F,   G,   H,   J,   K,   L,   SCLN,QUOT,ENT,  \
+        LSFT,NUBS,Z,   X,   C,   V,   B,   N,   M,   COMM,DOT, SLSH,FN0, ESC, \
+        FN4, LGUI,LALT,          SPC,                     APP, FN2, FN1, FN3),
+    [1] = LAYOUT( \
+        GRV, F1,  F2,  F3,  F4,  F5,  F6,  F7,  F8,  F9,  F10, F11, F12, TRNS,TRNS, \
+        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,\
+        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \
+        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,FN5, TRNS, \
+        TRNS,TRNS,TRNS,          TRNS,                    TRNS,FN7, FN6, FN8),
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+    [0] = ACTION_MODS_TAP_KEY(MOD_RSFT, KC_UP),
+    [1] = ACTION_MODS_TAP_KEY(MOD_RGUI, KC_DOWN),
+    [2] = ACTION_MODS_TAP_KEY(MOD_RALT, KC_LEFT),
+    [3] = ACTION_MODS_TAP_KEY(MOD_RCTL, KC_RIGHT),
+    [4] = ACTION_LAYER_MOMENTARY(1),
+    [5] = ACTION_MODS_TAP_KEY(MOD_RSFT, KC_PGUP),
+    [6] = ACTION_MODS_TAP_KEY(MOD_RGUI, KC_PGDN),
+    [7] = ACTION_MODS_TAP_KEY(MOD_RALT, KC_HOME),
+    [8] = ACTION_MODS_TAP_KEY(MOD_RCTL, KC_END),
+};
+
+```
+
+Touches double rôle : https://en.wikipedia.org/wiki/Modifier_key#Dual-role_keys
+
+## Eject sur Mac OSX
+
+Le keycode`KC_EJCT` fonctionne sous OSX. https://github.com/tmk/tmk_keyboard/issues/250
+
+Il semble que Windows 10 ignore le code et Linux/Xorg le reconnaît mais n'a pas de mapping par défaut.
+
+Nous ne sommes pas sûr quel keycode est utilisé pour la touche Eject sur les claviers Apple officiels. HHKB utilise `F20` pour la touche Eject (`Fn+f`) lorsqu'il est en mode Mac, mais ce n'est probablement pas la même chose que le keycode Eject d'Apple.
+
+## Qu'est-ce que `weak_mods` et `real_mods` dans `action_util.c`
+
+___TO BE IMPROVED___
+
+real_mods est prévu pour retenir l'état des touches modificateur réelles/physiques, alors que weak_mods ne retient l'état que des modificateurs temporaires ou virtuels qui ne devraient pas affecter l'état des touches modificaterus réelles.
+
+Par exemple, disons que vous maintenez la touche physique "shift gauche" et tapez ACTION_MODS_KEY(LSHIFT, KC_A),
+
+en weak_mods,
+
+* (1) maintenir shift gauche : real_mods |= MOD_BIT(LSHIFT)
+* (2) appuyer ACTION_MODS_KEY(LSHIFT, KC_A): weak_mods |= MOD_BIT(LSHIFT)
+* (3) lâcher ACTION_MODS_KEY(LSHIFT, KC_A): weak_mods &= ~MOD_BIT(LSHIFT)
+real_mods garde sur état modificateur.
+
+sans weak_mods,
+
+* (1) maintenir shift gauche : real_mods |= MOD_BIT(LSHIFT)
+* (2) appuyer ACTION_MODS_KEY(LSHIFT, KC_A): real_mods |= MOD_BIT(LSHIFT)
+* (3) lâcher ACTION_MODS_KEY(LSHIFT, KC_A): real_mods &= ~MOD_BIT(LSHIFT)
+ici real_mods a perdu son état pour 'shift gauche physique'.
+
+weak_mods est ORed avec real_mods lorsque le rapport du clavier est envoyé.
+https://github.com/tmk/tmk_core/blob/master/common/action_util.c#L57

docs/getting_started_vagrant.md

@@ -40,7 +40,7 @@ vagrant plugin install vagrant-vbguest
 Finished with your environment? From anywhere inside the folder where you checked out this project, Execute:
 
 ```console
-vagrant destory
+vagrant destroy
 ```
 
 ### What if I want to use Docker directly?
@@ -54,4 +54,4 @@ Execute the following to bypass the `vagrant` user booting directly to the offic
 
 ```console
 vagrant ssh -c 'sudo -i'
-```
+```

docs/he-il/README.md

@@ -0,0 +1,34 @@
+<div dir="rtl" markdown="1">
+# קושחה עבור Quantum Mechanical Keyboard
+
+[![גירסה נוכחית](https://img.shields.io/github/tag/qmk/qmk_firmware.svg)](https://github.com/qmk/qmk_firmware/tags)
+[![מצב הבניה](https://travis-ci.org/qmk/qmk_firmware.svg?branch=master)](https://travis-ci.org/qmk/qmk_firmware)
+[![ערוץ דיסקורד](https://img.shields.io/discord/440868230475677696.svg)](https://discord.gg/Uq7gcHh)
+[![מצב מסמכים](https://img.shields.io/badge/docs-ready-orange.svg)](https://docs.qmk.fm)
+[![תומכי GitHub](https://img.shields.io/github/contributors/qmk/qmk_firmware.svg)](https://github.com/qmk/qmk_firmware/pulse/monthly)
+[![מזלגות GitHub](https://img.shields.io/github/forks/qmk/qmk_firmware.svg?style=social&label=Fork)](https://github.com/qmk/qmk_firmware/)
+
+## מה היא קושחת QMK?
+
+QMK (*Quantum Mechanical Keyboard*) היא קהילת קוד פתוח (open source) שמתחזקת את קושחת QMK, QMK Toolbox, qmk.fm, והמסמכים המתאימים. קושחת QMK היא קושחה עבור מקלדות המבוססת על [tmk\_keyboard](http://github.com/tmk/tmk_keyboard) עם כמה תוספות עבור בקרי Atmel AVR ובאופן ספציפי יותר - [מוצרי OLKB](http://olkb.com), מקלדת [ErgoDox EZ](http://www.ergodox-ez.com), וגם [מוצרי Clueboard](http://clueboard.co/). בנוסף, הקושחה עברה פורט עבור שבבי ARM באמצעות ChibiOS. ניתן להשתמש בה על מנת להפעיל את מקלדות ה PCB המקוסטמות שלך.
+
+## איך להשיג אותה
+
+אם אתם מתכננים לתרום מיפוי מקשים, מקלדת או יכולת ל QMK, הדבר הקל ביותר הוא  [לעשות פורק לריפו בGithub](https://github.com/qmk/qmk_firmware#fork-destination-box), ולעשות קלון לריפו בסביבה המקומית ושם לבצע את השינויים שלכם, לדחוף אותם ולפתוח  [Pull Request](https://github.com/qmk/qmk_firmware/pulls) מהפורק שלך.
+
+אחרת, אפשר להוריד את הקושחה באופן ישיר ([zip](https://github.com/qmk/qmk_firmware/zipball/master), [tar](https://github.com/qmk/qmk_firmware/tarball/master)), או לשכפל אותה באמצעות git (`git@github.com:qmk/qmk_firmware.git`), או https (`https://github.com/qmk/qmk_firmware.git`).
+
+## איך לקמפל
+
+לפני שתצליחו לקמפל, תדרשו [להתקין סביבה](getting_started_build_tools.md) עבור פיתוח AVR ו/או ARM. ברגע שהדבר בוצע, תוכלו להריץ פקודת `make` כדי לבנות מקלדת ומיפוי עם התחביר הבא: 
+
+    make planck/rev4:default
+
+כך תוכלו לבנות את גרסא `rev4` של ה `planck` עם מיפוי ברירת המחדל (`default`). לא כל המקלדות בעלות גרסאות (נקרא גם תת-פרוייקט או תיקייה), במקרה כזה, אפשר להריץ את הפקודה הבאה: 
+
+    make preonic:default
+
+## איך להתאים
+
+לQMK יש המון [יכולות](features.md) שאפשר לנווט בהן, וכמות נכבדת של [תיעוד ודוקומנטציה](http://docs.qmk.fm) בה אפשר לנבור. רוב הפיצ׳רים באים לידי ביטוי על ידי שינוי  [מיפוי המקלדת](keymap.md) ושינוי  [קודי המקשים](keycodes.md).
+</div>

docs/he-il/_summary.md

@@ -0,0 +1,138 @@
+<div dir="rtl" markdown="1">
+**בשפה העברית**
+* [המדריך המלא למתחילים](newbs.md)
+  * [מקורות ללמידה](he-il/newbs_learn_more_resources.md)
+* [בסיס QMK](he-il/README.md)
+    * [מבוא לQMK](he-il/getting_started_introduction.md)
+    * [איך להשתמש בGithub](he-il/getting_started_github.md)
+    * [קבלת עזרה](he-il/getting_started_getting_help.md)
+* [שאלות נפוצות](he-il/faq.md)
+    * [שאלות נפוצות כלליות](he-il/faq_general.md)
+* [חומרה](he-il/hardware.md)
+* התייחסויות
+  * [איך לתעד נכון](he-il/documentation_best_practices.md)
+
+**בשפה האנגלית**
+* [המדריך המלא למתחילים](newbs.md)
+  * [התחלה](newbs_getting_started.md)
+  * [בנייה של הקושחה הראשונה שלך](newbs_building_firmware.md)
+  * [צריבה של הקושחה](newbs_flashing.md)
+  * [בדיקות ודיבאגינג](newbs_testing_debugging.md)
+  * [עבודה נכונה ב GIT](newbs_best_practices.md)
+  * [מקורות ללמידה](newbs_learn_more_resources.md)
+
+* [בסיס QMK](README.md)
+  * [מבוא לQMK](getting_started_introduction.md)
+  * [QMK CLI](cli.md)
+  * [QMK CLI Config](cli_configuration.md)
+  * [תרומה ל QMK](contributing.md)
+  * [איך להשתמש בGithub](getting_started_github.md)
+  * [קבלת עזרה](getting_started_getting_help.md)
+
+* [שינויים משמעותיים](breaking_changes.md)
+  * [2019 Aug 30](ChangeLog/20190830.md)
+
+* [שאלות נפוצות](faq.md)
+  * [שאלות נפוצות כלליות](faq_general.md)
+  * [בנייה/קומפילציה של QMK](faq_build.md)
+  * [דיבאגינג ופתרון תקלות של QMK](faq_debug.md)
+  * [מיפוי מקשים](faq_keymap.md)
+  * [התקנת דרייברים עם Zadig](driver_installation_zadig.md)
+
+* מדריכים מפורטים
+  * [התקנת כלי Build](getting_started_build_tools.md)
+  * [מדריך Vagrant](getting_started_vagrant.md)
+  * [הוראות בנייה/קומפילציה](getting_started_make_guide.md)
+  * [צריבת קושחה](flashing.md)
+  * [התאמה אישית של הפונקציונאליות](custom_quantum_functions.md)
+  * [מיפוי מקשים](keymap.md)
+
+* [חומרה](hardware.md)
+  * [מעבדי AVR](hardware_avr.md)
+  * [דרייברים](hardware_drivers.md)
+
+* התייחסויות
+  * [מדריך למקלדות](hardware_keyboard_guidelines.md)
+  * [אפשרויות הגדרות](config_options.md)
+  * [קודי מקשים](keycodes.md)
+  * [קונבנציות קוד - C](coding_conventions_c.md)
+  * [קונבנציות קוד - Python](coding_conventions_python.md)
+  * [איך לתעד נכון](documentation_best_practices.md)
+  * [טמפלטים לדוקומנטציה](documentation_templates.md)
+  * [מילון](reference_glossary.md)
+  * [בדיקות יחידה](unit_testing.md)
+  * [פונקציות שימושיות](ref_functions.md)
+  * [תמיכה בConfigurator](reference_configurator_support.md)
+  * [פורמט info.json](reference_info_json.md)
+  * [פיתוח בPython CLI](cli_development.md)
+
+* [תכונות](features.md)
+  * [Basic Keycodes](keycodes_basic.md)
+  * [US ANSI Shifted Keys](keycodes_us_ansi_shifted.md)
+  * [Quantum Keycodes](quantum_keycodes.md)
+  * [Advanced Keycodes](feature_advanced_keycodes.md)
+  * [Audio](feature_audio.md)
+  * [Auto Shift](feature_auto_shift.md)
+  * [Backlight](feature_backlight.md)
+  * [Bluetooth](feature_bluetooth.md)
+  * [Bootmagic](feature_bootmagic.md)
+  * [Combos](feature_combo.md)
+  * [Command](feature_command.md)
+  * [Debounce API](feature_debounce_type.md)
+  * [DIP Switch](feature_dip_switch.md)
+  * [Dynamic Macros](feature_dynamic_macros.md)
+  * [Encoders](feature_encoders.md)
+  * [Grave Escape](feature_grave_esc.md)
+  * [Haptic Feedback](feature_haptic_feedback.md)
+  * [HD44780 LCD Controller](feature_hd44780.md)
+  * [Key Lock](feature_key_lock.md)
+  * [Layouts](feature_layouts.md)
+  * [Leader Key](feature_leader_key.md)
+  * [LED Matrix](feature_led_matrix.md)
+  * [Macros](feature_macros.md)
+  * [Mouse Keys](feature_mouse_keys.md)
+  * [OLED Driver](feature_oled_driver.md)
+  * [One Shot Keys](feature_advanced_keycodes.md#one-shot-keys)
+  * [Pointing Device](feature_pointing_device.md)
+  * [PS/2 Mouse](feature_ps2_mouse.md)
+  * [RGB Lighting](feature_rgblight.md)
+  * [RGB Matrix](feature_rgb_matrix.md)
+  * [Space Cadet](feature_space_cadet.md)
+  * [Split Keyboard](feature_split_keyboard.md)
+  * [Stenography](feature_stenography.md)
+  * [Swap Hands](feature_swap_hands.md)
+  * [Tap Dance](feature_tap_dance.md)
+  * [Terminal](feature_terminal.md)
+  * [Thermal Printer](feature_thermal_printer.md)
+  * [Unicode](feature_unicode.md)
+  * [Userspace](feature_userspace.md)
+  * [Velocikey](feature_velocikey.md)
+
+* למייקרים ומודרים
+  * [מדריך לכתיבה ידנית](hand_wire.md)
+  * [מדריך לצריבת ISP](isp_flashing_guide.md)
+  * [מדריך לדיבאגינג ARM](arm_debugging.md)
+  * [מנהל התקן I2C](i2c_driver.md)
+  * [בקרת GPIO](internals_gpio_control.md)
+  * [המרת Proton C](proton_c_conversion.md)
+
+* להבנה עמוקה יותר
+  * [איך עובדות מקלדות](how_keyboards_work.md)
+  * [להבין את QMK](understanding_qmk.md)
+
+* נושאים נוספים
+  * [שימוש ב - Eclipse עם QMK](other_eclipse.md)
+  * [שימוש ב - VSCode עם QMK](other_vscode.md)
+  * [תמיכה](support.md)
+  * [כיצד להוסיף תרגום](translating.md)
+
+* QMK מבפנים (בתהליך)
+  * [Defines](internals_defines.md)
+  * [Input Callback Reg](internals_input_callback_reg.md)
+  * [Midi Device](internals_midi_device.md)
+  * [Midi Device Setup Process](internals_midi_device_setup_process.md)
+  * [Midi Util](internals_midi_util.md)
+  * [Send Functions](internals_send_functions.md)
+  * [Sysex Tools](internals_sysex_tools.md)
+
+</div>

docs/he-il/becoming_a_qmk_collaborator.md

@@ -0,0 +1,11 @@
+<div dir="rtl" markdown="1">
+# איך להפוך לשותף של QMK
+
+שותף של QMK הוא יצרן מקלדות או מעצב שמעוניין בלעזור ל-QMK לגדול ולתמוך במקלד(ו)ת שלהם, ולעודד את המשתמשים והצרכנים להוסיף יכולות, רעיונות ומיפויים. אנחנו תמיד מחפשים עוד מקלדות ומשתפי פעולה, אבל אנחנו מבקשים שיעמדו בדרישות הבאות:
+
+* **קיום לוח PCB למכירה.** לצערינו, יש יותר מידי הסתבכויות ובעיות עם מקלדות המחווטות ידנית.
+* **תחזוק המקלדת ב-QMK.** זה אולי רק ידרוש הגדרה בסיסית כדי לגרום למקלדת לעבוד, אבל זה גם יכול לכלול התאמה של שינויים בקוד הליבה של QMK שיכול לשבור קוד ייחודי שלכם.
+* **אישור ומיזוג Pull Requests של מיפויי מקלדת עבור המקלדת** אנחנו רוצים לעודד משתמשים לתרום את מיפויי המקלדת שלהם לאחרים כדי לעזור לאחרים להתחיל ליצור את שלהם.
+
+אם אתם עומדים בדרישות הללו, שלחו לנו מייל לכתובת  hello@qmk.fm עם מבוא וקישורים עבור המקלדת שלכם.
+</div>

docs/he-il/documentation_best_practices.md

@@ -0,0 +1,67 @@
+<div dir="rtl" markdown="1">
+# איך לתעד נכון
+
+עמוד זה קיים כדי לתעד את השיטות הטובות ביותר כאשר כותבים תיעוד עבור QMK. מעקב אחר הוראות אלה יעזור לשמור על סגנון וטון עקביים, אשר בתורם יעזרו לאנשים אחרים להבין טוב יותר את QMK.
+
+# פתיחת עמוד
+
+התיעוד שלך צריך בד״כ להפתח עם כותרת בגודל H1, אחריה פסקה אחת של תיאור של מה המשתמש ימצא בעמוד זה.
+זכור כי כותרת זו והפסקה ימוקמו ליד תוכן העניינים, אז חשוב לשמור על כותרת קצרה ולהמנע ממשפטים ארוכים ללא פיסוק.
+
+לדוגמה:
+
+```
+# הכותרת שלי
+
+עמוד זה מדבר על היכולת הסופר-מגניבה שלי. אתה יכול להשתמש ביכולת זו כדי להכין קפה, לסחוט תפוזים ולקבל משלוח של ביצים ועוגות מהסופר הקרוב באמצעות רחפן.
+```
+
+# כותרות
+
+עמוד התיעוד צריך לאופן כללי לכלול מס׳ כותרות בגודל "H1". רק כותרות מגודל H1 ו- H2 יכללו בתוכן העניינים, אז חשוב לתכנן אותם בהתאם. הכותרות לא להיות רחבות מידי כדי למנוע מתוכן העניינים להפוך להיות רחב מידי
+
+# בלוקי רמיזה מעוצבים
+
+ניתן להוסיף בלוקי רמיזה מעוצבים שמצויירים מסביב לטקסט כדי למשוך תשומת לב אליו.
+
+### חשוב
+
+```
+!> זה חשוב
+```
+
+יתרנדר כ:
+
+!> זה חשוב
+
+### טיפים כלליים
+
+```
+?> זהו טיפ שימושי.
+```
+
+יתרנדר כ:
+
+?> זהו טיפ שימושי.
+
+
+# תיעוד יכולות ופיצ׳ריםDocumenting Features
+
+אם יוצרים יכולת חדשה ב QMK, צרו עמוד תיעוד עבורה. העמוד לא צריך להיות ארוך במיוחד, מספר משפטים המתארים את היכולת (פיצ׳ר) וטבלה המתארת קודי מקשים רלוונטיים זה מספיק. הנה דוגמה בסיסית:
+
+```markdown
+# הפיצ׳ר המגניב שלי
+
+עמוד זה מדבר על היכולת הסופר-מגניבה שלי. אתה יכול להשתמש ביכולת זו כדי להכין קפה, לסחוט תפוזים ולקבל משלוח של ביצים ועוגות מהסופר הקרוב באמצעות רחפן.
+
+## קודי המקשים המגניבים של היכולת שלי
+
+|Long Name|Short Name|Description|
+|---------|----------|-----------|
+|KC_COFFEE||Make Coffee|
+|KC_CREAM||Order Cream|
+|KC_SUGAR||Order Sugar|
+```
+
+מקמו את התיעוד שלכם בתוך  `docs/feature_<my_cool_feature>.md`, והוסיפו קישור לקובץ זה במקום המתאים ב `docs/_sidebar.md`. אם הוספתם קודי מקשים נוספים, תקפידו להוסיף אותם ל-  `docs/keycodes.md` עם לינק לעמוד היכולת שלכם.
+</div>

docs/he-il/faq.md

@@ -0,0 +1,8 @@
+<div dir="rtl" markdown="1">
+# שאלות נפוצות
+
+* [כללי](faq_general.md)
+* [בנייה או קומפילציה של QMK](faq_build.md)
+* [דיבאגינג ופתרון בעיות של QMK](faq_debug.md)
+* [מיפוי מקשים](faq_keymap.md)
+</div>

docs/he-il/faq_general.md

@@ -0,0 +1,17 @@
+<div dir="rtl" markdown="1">
+# שאלות נפוצות
+
+## מה זה QMK?
+
+[QMK](https://github.com/qmk), קיצור עבור Quantum Mechanical Keyboard, הוא קבוצה של אנשים הבונים כלים עבור מקלדות מותאמות אישית. התחלנו עם  [קושחת QMK](https://github.com/qmk/qmk_firmware), פורק של [TMK](https://github.com/tmk/tmk_keyboard) אשר שונה באופן ניכר.
+
+## מה ההבדלים העיקריים בין QMK ו-Keymap TMK?
+
+TMK עוצב ומומש במקור ע״י [Jun Wako](https://github.com/tmk). QMK התחיל כפורק של [Jack Humbert](https://github.com/jackhumbert) של הפרוייקט של TMK עבור Planck. אחרי כמה זמן הפורק של ג׳ק השתנה מזה של TMK וב- 2015 ג׳ק החליט לשנות את שמו  של הפורק ל- QMK.
+
+מנק׳ מבט טכנית, QMK נבנה על גבי TMK ע״י הוספת יכולות ופיצ׳רים חדשים. ראוי לציון ש- QMK הרחיב את מס׳ קודי המקלדת האפשריים ומשתמש בהם למימוש יכולות מתקדמות כמו `S()`, `LCTL()`, ו- `MO()`. ניתן לראות רשימה מלאה של קודי המקלדת האלה ב - [קודי מקלדת](keycodes.md).
+
+מנק׳ מבט של הפרוייקט וניהול הקהילה, TMK מנהל את כל המקלדות הנתמכות בעצמו, עם מעט תמיכה מהקהילה. כל אחד יכול לעשות פורק מהפרוייקט עבור מקלדות אחרות. רק מס׳ מיפויי מקשים נמצאים בברירת המחדל כך שאנשים בד״כ לא משתפים מיפויי מקשים זה עם זה. QMK מעודד את השיתוף של המקלדות וקודי המקשים דרך רפוזיטורי בניהול מרכזי, אשר מקבל את כל בקשות ה- Pull Requests שעומדות בסטנדרט האיכות. רובם מנוהלות ע״י הקהילה, אבל הצוות של QMK עוזר כשנדרש.
+
+לשתי הגישות יש יתרונות וחסרונות וקוד עובר בחופשיות בין TMK ל- QMK כשצריך.
+</div>

docs/he-il/getting_started_getting_help.md

@@ -0,0 +1,17 @@
+<div dir="rtl" markdown="1">
+# קבלת עזרה
+
+ישנם משאבים רבים לצורך קבלת עזרה עם QMK.
+
+## צ׳אט בזמן אמת
+
+אפשר למצוא מפתחי QMK ומשתמשים [בשרת ה-Discord הראשי שלנו](https://discord.gg/Uq7gcHh). ישנם ערוצים ספציפיים בשרת לצורך שיחות על הקושחה, ארגז הכלים, חומרה והמגדיר.
+
+## סאב-רדיט OLKB
+
+הפורום הרשמי של QMK נמצא ב - [/r/olkb](https://reddit.com/r/olkb) באתר [reddit.com](https://reddit.com).
+
+## סוגיות Github
+
+ניתן לפתוח [סוגייה ב-GitHub](https://github.com/qmk/qmk_firmware/issues). הדבר שימושי במיוחד כאשר הסוגיה דורשת דיון עמוק וארוך או דיבאגינג.
+</div>

docs/he-il/getting_started_github.md

@@ -0,0 +1,69 @@
+<div dir="rtl" markdown="1">
+# איך להשתמש ב-Github עם QMK
+
+Github עלול להיות קצת טריקי למי שלא מכיר את העבודה איתו - מדריך זה ילווה אתכם שלב אחר שלב דרך ביצוע פעולות fork, clone ו-pull request עם QMK.
+
+?> מדריך זה מניח שאתם מרגישים בנוח עם הרצה של פקודות בסביבת command line (שורת הפקודה) ו-git מותקן במערכת שלכם.
+
+התחילו ב- [עמוד של QMK ב-Github](https://github.com/qmk/qmk_firmware), ותצמאו כפתור בחלק העליון מימין עם התיכוב "Fork":
+
+![Fork ב-Github](http://i.imgur.com/8Toomz4.jpg)
+
+אם אתם חלק מארגון, תצטרכו לבחור לאיזה חשבון לבצע פעולת fork. ברוב המבקרים, תרצו לבצע fork לתוך החשבון הפרטי שלכם. ברגע שה-fork הסתיים (לפעמים זה יכול לקחת קצת זמן) הקליקו על כפתור ה-"Clone or Download":
+
+![הורדה מ-Github](http://i.imgur.com/N1NYcSz.jpg)
+
+תוודאו שאתם בוחרים באופצייה של  "HTTPS", בחרו את הקישור והעתיקו אותו:
+
+![קישור HTTPS](http://i.imgur.com/eGO0ohO.jpg)
+
+מכאן והלאה, הקיש `git clone ` בשורת הפקודה והדביקו את הלינק שלכם:
+
+<div dir="ltr" markdown="1">
+
+```
+user@computer:~$ git clone https://github.com/whoeveryouare/qmk_firmware.git
+Cloning into 'qmk_firmware'...
+remote: Counting objects: 46625, done.
+remote: Compressing objects: 100% (2/2), done.
+remote: Total 46625 (delta 0), reused 0 (delta 0), pack-reused 46623
+Receiving objects: 100% (46625/46625), 84.47 MiB | 3.14 MiB/s, done.
+Resolving deltas: 100% (29362/29362), done.
+Checking out files: 100% (2799/2799), done.
+```
+
+</div>
+
+כעת, יש לכם את ה-fork של QMK על המכונה המקומית שלכם ואתם יכולים להוסיף את מיפויי המקשים שלכם, לקמפל את הפרוייקט ולצרוב אותו על הלוח שלכם. כשאתם שלמים עם השינוי שעשיתם, תוכלו להוסיף, לבצע פעולת commit ולדחוף את השינויים ל-fork שלכם באופן הבא:
+
+<div dir="ltr" markdown="1">
+
+```
+user@computer:~$ git add .
+user@computer:~$ git commit -m "adding my keymap"
+[master cccb1608] adding my keymap
+ 1 file changed, 1 insertion(+)
+ create mode 100644 keyboards/planck/keymaps/mine/keymap.c
+user@computer:~$ git push
+Counting objects: 1, done.
+Delta compression using up to 4 threads.
+Compressing objects: 100% (1/1), done.
+Writing objects: 100% (1/1), 1.64 KiB | 0 bytes/s, done.
+Total 1 (delta 1), reused 0 (delta 0)
+remote: Resolving deltas: 100% (1/1), completed with 1 local objects.
+To https://github.com/whoeveryouare/qmk_firmware.git
+ + 20043e64...7da94ac5 master -> master
+```
+
+</div>
+
+השינויים שלכם יופיעו ב-fork שלכם ב-GitHub - אם תחזרו לשם  (`https://github.com/<whoeveryouare>/qmk_firmware`), תוכלו ליצור "Pull Request חדש" ע״י הקשה על הכפתור הבא:
+
+![Pull Request חדש](http://i.imgur.com/DxMHpJ8.jpg)
+
+כאן תוכלו לראות בדיוק למה עשיתם commit - אם הכל נראה תקין, תוכלו להשלים את הפעולה ע״י הקשה על  "Create Pull Request":
+
+![צרו Pull Request](http://i.imgur.com/Ojydlaj.jpg)
+
+אחרי שהגשתם, אנו עלולים לפנות אליכם לגבי השינויים שהצעתם, נבקש שתבצעו שינויים ובסופו של דבר נקבל את השינויים! תודה שתרמתם לפרוייקט QMK :)
+</div>

docs/he-il/getting_started_introduction.md

@@ -0,0 +1,72 @@
+<div dir="rtl" markdown="1">
+# מבוא
+
+עמוד זה מנסה להסביר את המידע הבסיסי אותו תדרשו לדעת כדי לעבוד עם פרוייקט QMK. הוא מניח שאתם יודעים איך לנווט בסביבת Unix Shell, אבל לא מניח שאתם מכירים את שפת C או קומפילציה באמצעות make.
+
+## מבנה QMK בסיסי
+
+QMK הוא פורק של הפרוייקט [tmk_keyboard](https://github.com/tmk/tmk_keyboard) של [Jun Wako](https://github.com/tmk). קוד הTMK המקורי, עם התאמות, יכול להמצא בתיקיית `tmk`. התוספות של QMK לפרוייקט יכולות להמצא בתיקיית `quantum`. פרוייקטי מקלדות יכולות להמצא בתיקיות `handwired` ו- `keyboard`.
+
+### מבנה אחסון המשתמש
+
+בתוך תיקיית `users` יש תיקייה לכל משתמש. זה המקום למשתמשים להוסיף קוד שהם רוצים להשתמש בו במקלדות שונות. מומלץ לעיין במסמך [תכונות אחסון המשתמש](feature_userspace.md) לקבלת מידע נוסף.
+
+### מבנה פרוייקט המקלדת
+
+בתוך תיקיית `keyboards`, תת התיקייה `handwired` ותת התיקיות של היצרן והמוכר, לדוגמה `clueboard` היא תיקייה לכל פרוייקט מקלדת - `qmk_firmware/keyboards/clueboard/2x1800` בתוך התיקייה הזאת תמצאו את המבנה הבא:
+
+
+* `keymaps/`: מיפויי מקשים שונים היכולים להבנות
+* `rules.mk`: קובץ המגדיר את הגדרות ברירת המחדל של `make`. נא לא לערוך את הקובץ ישירות, במקום זאת, השתמשו בקובץ מיפוי המקשים ספציפי `rules.mk`.
+* `config.h`: הקובץ מכיל הגדרות לזמן הקומפילציה. נא לא לערוך את הקובץ ישירות אלא להשתמש בקובץ `config.h` לכל מיפויי מקשים.
+* `info.json`: הקובץ מכיל הגדרות פריסה עבור QMK Configurator. צפו ב [תמיכת Configurator](reference_configurator_support.md) למידע נוסף.
+* `readme.md`: סקירה כללית של המקלדת.
+* `<keyboardName>.h`: הקובץ בו פריסת המקלדת מוגדרת אל מול מטריצת המתגים של המקלדת.
+* `<keyboardName>.c`: הקובץ בו ניתן למצוא קוד מותאם למקלדת.
+
+למידע נוסף - אנא הכנסו ל [QMK](hardware_keyboard_guidelines.md).
+For more information on project structure, see [QMK מדריך למקלדת](hardware_keyboard_guidelines.md).
+
+### מבנה מפיוי המקשים
+
+בכל ספריית מיפוי מקשים, הקבצים הבאים עלולים להמצא. רק הקובץ `keymap.c` הוא חובה, אם השאר לא נמצאים, אפשרויות ברירת המחדל יבחרו.
+In every keymap folder, the following files may be found. Only `keymap.c` is required, and if the rest of the files are not found the default options will be chosen.
+
+* `config.h`: ההגדרות השונות עבור מיפוי המקשים.
+* `keymap.c`: כל הקודים של מיפוי המקשים, קובץ חובה
+* `rules.mk`: אילו יכולות של QMK מאופשרות.
+* `readme.md`: הסבר על מיפוי המקשים, איך אחרים ישתמשו בו והסבר על היכולות. נא להעלות תמונות לשירותים כמו imgur.
+
+# קובץ `config.h` 
+
+לקובץ `config.h` יש 3 מיקומים אפשריים:
+
+* keyboard (`/keyboards/<keyboard>/config.h`)
+* userspace (`/users/<user>/config.h`)
+* keymap (`/keyboards/<keyboard>/keymaps/<keymap>/config.h`)
+
+מערכת הבילד אוטומטית בוחרת את קובץ ההגדרות לפי הסדר הנ״ל. אם רוצים לדרוס הגדרה מסויימת שהוגדרה בקובץ `config.h` קודם, ראשית תצטרכו להשתמש בקוד מוכן עבור ההגדרות שאתם רוצים לשנות.
+
+<div dir="ltr"  markdown="1">
+
+```
+#pragma once
+```
+
+</div>
+
+כדי לדרוס הגדרות מקובץ `config.h` קודם, אתם מוכרחים להשתמש בפקודת `#undef` ואז שוב `#define`.
+
+דוגמה לקוד כזה נראית כך:
+<div dir="ltr"  markdown="1">
+
+```
+#pragma once
+
+// overrides go here!
+#undef MY_SETTING
+#define MY_SETTING 4
+```
+
+</div>
+</div>

docs/he-il/hardware.md

@@ -0,0 +1,10 @@
+<div dir="rtl" markdown="1">
+# חומרה
+
+QMK רצה על מגוון של חומרות. אם המעבד שלך יכול להיות ממוקד (מטורגט) ע״י [LUFA](http://www.fourwalledcubicle.com/LUFA.php) או [ChibiOS](http://www.chibios.com) כנראה שתוכל לגרום ל QMK לרוץ על המעבד. קטע זה מדבר על הרצת QMK, ותקשורת עם, סוגים שונים של חומרות.
+
+* [מדריך למקלדת](hardware_keyboard_guidelines.md)
+* [מעבדי AVR](hardware_avr.md)
+* מעבדי ARM (TBD)
+* [מנהלי התקנים](hardware_drivers.md)
+</div>

docs/he-il/newbs_learn_more_resources.md

@@ -0,0 +1,16 @@
+<div dir="rtl" markdown="1">
+# מקורות ללמידה
+
+המקורות הבאים מטרתם היא לתת למשתמשים חדשים בקהילת QMK כדי להבין לעומק את המידע שמגיע במסמכי המתחילים.
+
+מקורות גיט:
+
+* [מדריך כללי מעולה](https://www.codecademy.com/learn/learn-git)
+* [משחק גיט כדי ללמוד מדוגמאות](https://learngitbranching.js.org/)
+* [מקורות גיט כדי ללמוד עוד על GitHub](getting_started_github.md)
+* [מקור גיט כדי ללמוד במפורש על QMK](contributing.md)
+
+מקורות לפקודות שורה (Command Line):
+
+* [מדריך טוב על Command Line](https://www.codecademy.com/learn/learn-the-command-line)
+</div>

docs/he-il/proton_c_conversion.md

@@ -0,0 +1,36 @@
+<div dir="rtl" markdown="1">
+# המרה של לוח להשתמש ב-Proton C
+
+אם לוח נתמך ב-QMK משתמש בלוח Pro Micro (או כל לוח נתמך) ואתם רוצים להשתמש ב-Proton C, ניתן לייצר את החומרה ע"י הוספה של הפקודה `CONVERT_TO_PROTON_C=yes` (או `CTPC=yes`) לפקודת make, כמו כאן:
+<div dir="ltr" markdown="1">
+
+```
+    make 40percentclub/mf68:default CTPC=yes
+```
+
+</div>
+ניתן להוסיף את אותו ארגומנט לקובץ `rules.mk` במיפוי המקשים שלכם, שתיצור את אותה התוצאה.
+
+הדבר חושף את דגל `CONVERT_TO_PROTON_C` שניתן להשתמש בו בקוד שלכם באמצעות פקודת `#ifdef`, כמו כאן:
+<div dir="ltr" markdown="1">
+
+```
+    #ifdef CONVERT_TO_PROTON_C
+        // Proton C code
+    #else
+        // Pro Micro code
+    #endif
+```
+
+</div>
+לפני שתצליחו לקמפל, יכול להיות שתקבלו שגיאות שונות לגבי `PORTB/DDRB`, וכו' שלא הוגדרו, אם כך, תצטרכו להמיר את קודי המקלדת להשתמש ב - [בקרי GPIO](internals_gpio_control.md) שיעבדו עבור ARM וגם AVR. הדבר לא אמור להשפיע על הבילדים של AVR בכלל.
+
+ל-Proton C יש רק מנורת LED אחת על הלוח (C13), וכברירת מחדל, TXLED (D5) ממופה אליו. אם תרצו במקום, למפות אליו את  RXLED (B0), הוסיפו את השורה הבא לקובץ `config.h`:
+<div dir="ltr"  markdown="1">
+
+```
+    #define CONVERT_TO_PROTON_C_RXLED
+```
+
+</div>
+</div>

docs/he-il/quantum_keycodes.md

@@ -0,0 +1,35 @@
+<div dir="rtl" markdown="1">
+# קודי מקלדת Quantum
+
+קודי מקלדת Quantum מאפשרים התאמה נוחה יותר של מיפוי המקשים שלך מעבר למה שהבסיסי מאפשר, ללא צורך בהגדרת של פעולות מותאמות אישית.
+
+כל קודי המקלדת בתוך quantum הם מספרים בין `0x0000` ֿֿֿ ל-`0xFFFF`. בתוך הקובץ `keymap.c` זה עלול להראות כאילו יש לך פונקציות ומקרים יחודיים נוספים, אבל בסופו של דבר הקדם-מעבד של שפת C יתרגם אלה לתוך מספר יחיד בין 4 בתים. QMK שמרה את מרחב הכתובות בין `0x0000` עד ל- `0x00FF` עבור קודי מקשים סטנדרטיים. קודי מקשים אלה, כגון `KC_A`, `KC_1`, ו- `KC_LCTL`, אשר מתארים מקשים בסיסיים מוגדרים בתוך USB HID specification.
+
+בעמודו זה יש לנו את קודי המקשים מתועדים בין `0x00FF` ֿֿ ל- `0xFFFF` אשר משומשים בשביל לממש יכולות מתקדמות של quantum. אם תגדירו קודי מקשים משלכם, הם יתווספו לתוך המרחב הזה גם כן.
+
+## קודי מקשים של QMK
+<div dir="ltr"  markdown="1">
+
+```
+|Key            |Aliases    |Description                                                          |
+|---------------|-----------|---------------------------------------------------------------------|
+|`RESET`        |           |Put the keyboard into DFU mode for flashing                          |
+|`DEBUG`        |           |Toggle debug mode                                                    |
+|`EEPROM_RESET` |`EEP_RST`  |Resets EEPROM state by reinitializing it                             |
+|`KC_GESC`      |`GRAVE_ESC`|Escape when tapped, <code>&#96;</code> when pressed with Shift or GUI|
+|`KC_LSPO`      |           |Left Shift when held, `(` when tapped                                |
+|`KC_RSPC`      |           |Right Shift when held, `)` when tapped                               |
+|`KC_LCPO`      |           |Left Control when held, `(` when tapped                              |
+|`KC_RCPC`      |           |Right Control when held, `)` when tapped                             |
+|`KC_LAPO`      |           |Left Alt when held, `(` when tapped                                  |
+|`KC_RAPC`      |           |Right Alt when held, `)` when tapped                                 |
+|`KC_SFTENT`    |           |Right Shift when held, Enter when tapped                             |
+|`KC_LEAD`      |           |The [Leader key](feature_leader_key.md)                              |
+|`KC_LOCK`      |           |The [Lock key](feature_key_lock.md)                                  |
+|`FUNC(n)`      |`F(n)`     |Call `fn_action(n)` (deprecated)                                     |
+|`M(n)`         |           |Call macro `n`                                                       |
+|`MACROTAP(n)`  |           |Macro-tap `n` idk FIXME                                              |
+```
+
+</div>
+</div>

docs/index.html

@@ -6,7 +6,7 @@
   <link rel="icon" type="image/png" href="gitbook/images/favicon.png">
   <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
   <meta name="description" content="Description">
-  <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">  
+  <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
   <meta property="og:title" content="QMK Firmware Docs">
   <meta property="og:type" content="website">
   <meta property="og:description" content="The full documentation of the open-source firmware">
@@ -39,10 +39,12 @@
       search: {
         paths: 'auto',
         placeholder: {
+          '/es/': 'Buscar',
           '/zh-cn/': '搜索',
           '/': 'Search'
         },
         noData: {
+          '/es/': '¡Ningún resultado!',
           '/zh-cn/': '没有结果!',
           '/': 'No results!'
         },

docs/keycodes.md

@@ -297,6 +297,16 @@ This is a reference only. Each group of keys links to the page documenting their
 |`OUT_USB` |USB only                                      |
 |`OUT_BT`  |Bluetooth only                                |
 
+## [Dynamic Macros](feature_dynamic_macros.md)
+
+|Key              |Alias    |Description                                       |
+|-----------------|---------|--------------------------------------------------|
+|`DYN_REC_START1` |`DM_REC1`|Start recording Macro 1                           |
+|`DYN_REC_START2` |`DM_REC2`|Start recording Macro 2                           |
+|`DYN_MACRO_PLAY1`|`DM_PLY1`|Replay Macro 1                                    |
+|`DYN_MACRO_PLAY2`|`DM_PLY2`|Replay Macro 2                                    |
+|`DYN_REC_STOP`   |`DM_RSTP`|Finish the macro that is currently being recorded.|
+
 ## [Layer Switching](feature_advanced_keycodes.md#switching-and-toggling-layers)
 
 |Key             |Description                                                                       |

docs/proton_c_conversion.md

@@ -19,3 +19,13 @@ Before being able to compile, you may get some errors about `PORTB/DDRB`, etc no
 The Proton C only has one on-board LED (C13), and by default, the TXLED (D5) is mapped to it. If you want the RXLED (B0) mapped to it instead, add this like to your `config.h`:
 
     #define CONVERT_TO_PROTON_C_RXLED
+
+## Feature Conversion
+
+These are defaults based on what has been implemented for ARM boards.
+
+| Feature                             | Notes                                                                                                            |
+|-------------------------------------|------------------------------------------------------------------------------------------------------------------|
+| [Audio](feature_audio.md)           | Enabled                                                                                                          |  
+| [RGB Lighting](feature_rgblight.md) | Disabled                                                                                                         |
+| [Backlight](feature_backlight.md)   | Forces [task driven PWM](feature_backlight.md#software-pwm-driver) until ARM can provide automatic configuration |

docs/ru-ru/getting_started_getting_help.md

@@ -0,0 +1,15 @@
+# Получение помощи
+
+Существует много ресурсов для получения помощи по работе с QMK.
+
+## Чат в реальном времени
+
+Вы можете найти разработчиков и пользователей QMK на нашем главном [сервере Discord](https://discord.gg/Uq7gcHh). На сервере есть специальные каналы для разговоров о прошивке, Toolbox, оборудовании и конфигураторе.
+
+## OLKB Сабреддит
+
+Официальный форум QMK [/r/olkb](https://reddit.com/r/olkb) на [reddit.com](https://reddit.com).
+
+## GitHub ишью
+
+Вы можете открыть [ишью на GitHub](https://github.com/qmk/qmk_firmware/issues). Это особенно удобно, когда ваша проблема потребует длительного обсуждения или отладки.

drivers/arm/i2c_master.h

@@ -73,19 +73,19 @@
 // The default timing values below configures the I2C clock to 400khz assuming a 72Mhz clock
 // For more info : https://www.st.com/en/embedded-software/stsw-stm32126.html
 #    ifndef I2C1_TIMINGR_PRESC
-#        define I2C1_TIMINGR_PRESC 15U
+#        define I2C1_TIMINGR_PRESC 0U
 #    endif
 #    ifndef I2C1_TIMINGR_SCLDEL
-#        define I2C1_TIMINGR_SCLDEL 4U
+#        define I2C1_TIMINGR_SCLDEL 7U
 #    endif
 #    ifndef I2C1_TIMINGR_SDADEL
-#        define I2C1_TIMINGR_SDADEL 2U
+#        define I2C1_TIMINGR_SDADEL 0U
 #    endif
 #    ifndef I2C1_TIMINGR_SCLH
-#        define I2C1_TIMINGR_SCLH 15U
+#        define I2C1_TIMINGR_SCLH 38U
 #    endif
 #    ifndef I2C1_TIMINGR_SCLL
-#        define I2C1_TIMINGR_SCLL 21U
+#        define I2C1_TIMINGR_SCLL 129U
 #    endif
 #endif
 

drivers/oled/oled_driver.c

@@ -431,6 +431,15 @@ void oled_write_ln(const char *data, bool invert) {
     oled_advance_page(true);
 }
 
+void oled_write_raw(const char *data, uint16_t size) {
+    if (size > OLED_MATRIX_SIZE) size = OLED_MATRIX_SIZE;
+    for (uint16_t i = 0; i < size; i++) {
+        if (oled_buffer[i] == data[i]) continue;
+        oled_buffer[i] = data[i];
+        oled_dirty |= (1 << (i / OLED_BLOCK_SIZE));
+    }
+}
+
 #if defined(__AVR__)
 void oled_write_P(const char *data, bool invert) {
     uint8_t c = pgm_read_byte(data);
@@ -444,6 +453,16 @@ void oled_write_ln_P(const char *data, bool invert) {
     oled_write_P(data, invert);
     oled_advance_page(true);
 }
+
+void oled_write_raw_P(const char *data, uint16_t size) {
+    if (size > OLED_MATRIX_SIZE) size = OLED_MATRIX_SIZE;
+    for (uint16_t i = 0; i < size; i++) {
+        uint8_t c = pgm_read_byte(++data);
+        if (oled_buffer[i] == c) continue;
+        oled_buffer[i] = c;
+        oled_dirty |= (1 << (i / OLED_BLOCK_SIZE));
+    }
+}
 #endif  // defined(__AVR__)
 
 bool oled_on(void) {
@@ -566,4 +585,4 @@ void oled_task(void) {
 #endif
 }
 
-__attribute__((weak)) void oled_task_user(void) {}
+__attribute__((weak)) void oled_task_user(void) {}

drivers/oled/oled_driver.h

@@ -200,6 +200,8 @@ void oled_write(const char *data, bool invert);
 // Advances the cursor to the next page, wiring ' ' to the remainder of the current page
 void oled_write_ln(const char *data, bool invert);
 
+void oled_write_raw(const char *data, uint16_t size);
+
 #if defined(__AVR__)
 // Writes a PROGMEM string to the buffer at current cursor position
 // Advances the cursor while writing, inverts the pixels if true
@@ -211,6 +213,8 @@ void oled_write_P(const char *data, bool invert);
 // Advances the cursor to the next page, wiring ' ' to the remainder of the current page
 // Remapped to call 'void oled_write_ln(const char *data, bool invert);' on ARM
 void oled_write_ln_P(const char *data, bool invert);
+
+void oled_write_raw_P(const char *data, uint16_t size);
 #else
 // Writes a string to the buffer at current cursor position
 // Advances the cursor while writing, inverts the pixels if true
@@ -254,4 +258,4 @@ bool oled_scroll_off(void);
 uint8_t oled_max_chars(void);
 
 // Returns the maximum number of lines that will fit on the oled
-uint8_t oled_max_lines(void);
+uint8_t oled_max_lines(void);

keyboards/9key/keymaps/bcat/keymap.c

@@ -5,11 +5,8 @@ enum layer {
     LAYER_FUNCTION,
 };
 
-/* Switch to function layer when held. */
 #define LY_FUNC MO(LAYER_FUNCTION)
-
-/* Send Ctrl+Alt+L (Cinnamon screen lock shortcut) when pressed. */
-#define KY_LOCK LCA(KC_L)
+#define KY_LOCK LCA(KC_L)  /* Cinnamon lock screen */
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     [LAYER_DEFAULT] = LAYOUT(

keyboards/9key/keymaps/bcat/rules.mk

@@ -1 +0,0 @@
-BOOTLOADER = caterina  # Pro Micro

keyboards/ai03/orbit/serial.c

@@ -17,7 +17,6 @@
 #include <stddef.h>
 #include <stdbool.h>
 #include "serial.h"
-//#include <pro_micro.h>
 
 #ifdef SOFT_SERIAL_PIN
 

keyboards/ares/ares.c

@@ -17,50 +17,12 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include "ares.h"
 
-#ifdef RGBLIGHT_ENABLE
-
-#include <string.h>
-#include "i2c_master.h"
-#include "rgblight.h"
-
-extern rgblight_config_t rgblight_config;
-
-void matrix_init_kb(void) {
-  i2c_init();
-  // call user level keymaps, if any
-  matrix_init_user();
-}
-
-// custom RGB driver
-void rgblight_set(void) {
-  if (!rgblight_config.enable) {
-    memset(led, 0, 3 * RGBLED_NUM);
-  }
-
-  i2c_transmit(0xb0, (uint8_t*)led, 3 * RGBLED_NUM, 100);
-}
-
-bool rgb_init = false;
-
-void matrix_scan_kb(void) {
-  // if LEDs were previously on before poweroff, turn them back on
-  if (rgb_init == false && rgblight_config.enable) {
-    i2c_transmit(0xb0, (uint8_t*)led, 3 * RGBLED_NUM, 100);
-    rgb_init = true;
-  }
-
-  rgblight_task();
-  matrix_scan_user();
-}
-
-#endif
-
 #ifdef BACKLIGHT_ENABLE
 void backlight_init_ports(void) {
-    setPinOutput(D0);
-    setPinOutput(D1);
-    setPinOutput(D4);
-    setPinOutput(D6);
+	setPinOutput(D0);
+	setPinOutput(D1);
+	setPinOutput(D4);
+	setPinOutput(D6);
 }
 
 void backlight_set(uint8_t level) {
@@ -79,29 +41,3 @@ void backlight_set(uint8_t level) {
 	}
 }
 #endif
-
-// Optional override functions below.
-// You can leave any or all of these undefined.
-// These are only required if you want to perform custom actions.
-
-/*
-void matrix_init_kb(void) {
-  // put your keyboard start-up code here
-  // runs once when the firmware starts up
-  matrix_init_user();
-}
-void matrix_scan_kb(void) {
-  // put your looping keyboard code here
-  // runs every cycle (a lot)
-  matrix_scan_user();
-}
-bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
-  // put your per-action keyboard code here
-  // runs for every action, just before processing by the firmware
-  return process_record_user(keycode, record);
-}
-void led_set_kb(uint8_t usb_led) {
-  // put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
-  led_set_user(usb_led);
-}
-*/

keyboards/ares/rules.mk

@@ -1,18 +1,3 @@
-# Copyright 2017 Luiz Ribeiro <luizribeiro@gmail.com>
-#
-# 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/>.
-
 # MCU name
 MCU = atmega32a
 
@@ -34,8 +19,6 @@ CONSOLE_ENABLE = yes
 COMMAND_ENABLE = yes
 BACKLIGHT_ENABLE = no
 RGBLIGHT_ENABLE = no
-RGBLIGHT_CUSTOM_DRIVER = yes
+WS2812_DRIVER = i2c
 
 OPT_DEFS = -DDEBUG_LEVEL=0
-
-SRC += i2c_master.c

keyboards/bfake/bfake.c

@@ -16,51 +16,34 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "bfake.h"
-#ifdef BACKLIGHT_ENABLE
-#include "backlight.h"
-#endif
-#ifdef RGBLIGHT_ENABLE
-#include "rgblight.h"
-#endif
-
-#include <avr/pgmspace.h>
-
-#include "action_layer.h"
-#include "i2c.h"
-#include "quantum.h"
-
-#ifdef RGBLIGHT_ENABLE
-extern rgblight_config_t rgblight_config;
-
-void rgblight_set(void) {
-    if (!rgblight_config.enable) {
-        for (uint8_t i = 0; i < RGBLED_NUM; i++) {
-            led[i].r = 0;
-            led[i].g = 0;
-            led[i].b = 0;
-        }
-    }
-
-    i2c_init();
-    i2c_send(0xb0, (uint8_t*)led, 3 * RGBLED_NUM);
-}
-#endif
 
 __attribute__ ((weak))
-void matrix_scan_user(void) {
-}
+void matrix_scan_user(void) {}
 
 void backlight_init_ports(void) {
-	DDRD |= (1<<0 | 1<<1 | 1<<4 | 1<<6);
-	PORTD &= ~(1<<0 | 1<<1 | 1<<4 | 1<<6);
+	setPinOutput(D0);
+	setPinOutput(D1);
+	setPinOutput(D4);
+	setPinOutput(D6);
+
+	writePinLow(D0);
+	writePinLow(D1);
+	writePinLow(D4);
+	writePinLow(D6);
 }
 
 void backlight_set(uint8_t level) {
 	if (level == 0) {
 		// Turn out the lights
-		PORTD &= ~(1<<0 | 1<<1 | 1<<4 | 1<<6);
+		writePinLow(D0);
+		writePinLow(D1);
+		writePinLow(D4);
+		writePinLow(D6);
 	} else {
 		// Turn on the lights
-		PORTD |= (1<<0 | 1<<1 | 1<<4 | 1<<6);
+		writePinHigh(D0);
+		writePinHigh(D1);
+		writePinHigh(D4);
+		writePinHigh(D6);
 	}
 }

keyboards/bfake/i2c.c

@@ -1,106 +0,0 @@
-/*
-Copyright 2016 Luiz Ribeiro <luizribeiro@gmail.com>
-
-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/>.
-*/
-
-// Please do not modify this file 
-
-#include <avr/io.h>
-#include <util/twi.h>
-
-#include "i2c.h"
-
-void i2c_set_bitrate(uint16_t bitrate_khz) {
-    uint8_t bitrate_div = ((F_CPU / 1000l) / bitrate_khz);
-    if (bitrate_div >= 16) {
-        bitrate_div = (bitrate_div - 16) / 2;
-    }
-    TWBR = bitrate_div;
-}
-
-void i2c_init(void) {
-    // set pull-up resistors on I2C bus pins
-    PORTC |= 0b11;
-
-    i2c_set_bitrate(400);
-
-    // enable TWI (two-wire interface)
-    TWCR |= (1 << TWEN);
-
-    // enable TWI interrupt and slave address ACK
-    TWCR |= (1 << TWIE);
-    TWCR |= (1 << TWEA);
-}
-
-uint8_t i2c_start(uint8_t address) {
-    // reset TWI control register
-    TWCR = 0;
-
-    // begin transmission and wait for it to end
-    TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);
-    while (!(TWCR & (1<<TWINT)));
-
-    // check if the start condition was successfully transmitted
-    if ((TWSR & 0xF8) != TW_START) {
-        return 1;
-    }
-
-    // transmit address and wait
-    TWDR = address;
-    TWCR = (1<<TWINT) | (1<<TWEN);
-    while (!(TWCR & (1<<TWINT)));
-
-    // check if the device has acknowledged the READ / WRITE mode
-    uint8_t twst = TW_STATUS & 0xF8;
-    if ((twst != TW_MT_SLA_ACK) && (twst != TW_MR_SLA_ACK)) {
-        return 1;
-    }
-
-    return 0;
-}
-
-void i2c_stop(void) {
-    TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
-}
-
-uint8_t i2c_write(uint8_t data) {
-    TWDR = data;
-
-    // transmit data and wait
-    TWCR = (1<<TWINT) | (1<<TWEN);
-    while (!(TWCR & (1<<TWINT)));
-
-    if ((TWSR & 0xF8) != TW_MT_DATA_ACK) {
-        return 1;
-    }
-
-    return 0;
-}
-
-uint8_t i2c_send(uint8_t address, uint8_t *data, uint16_t length) {
-    if (i2c_start(address)) {
-        return 1;
-    }
-
-    for (uint16_t i = 0; i < length; i++) {
-        if (i2c_write(data[i])) {
-            return 1;
-        }
-    }
-
-    i2c_stop();
-
-    return 0;
-}

keyboards/bfake/i2c.h

@@ -1,27 +0,0 @@
-/*
-Copyright 2016 Luiz Ribeiro <luizribeiro@gmail.com>
-
-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/>.
-*/
-
-// Please do not modify this file 
-
-#ifndef __I2C_H__
-#define __I2C_H__
-
-void i2c_init(void);
-void i2c_set_bitrate(uint16_t bitrate_khz);
-uint8_t i2c_send(uint8_t address, uint8_t *data, uint16_t length);
-
-#endif

keyboards/bfake/rules.mk

@@ -1,18 +1,3 @@
-# Copyright 2017 Luiz Ribeiro <luizribeiro@gmail.com>
-#
-# 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/>.
-
 # MCU name
 MCU = atmega32a
 
@@ -34,10 +19,10 @@ CONSOLE_ENABLE = yes
 COMMAND_ENABLE = yes
 BACKLIGHT_ENABLE = no
 RGBLIGHT_ENABLE = no
-RGBLIGHT_CUSTOM_DRIVER = yes
+WS2812_DRIVER = i2c
 
 OPT_DEFS = -DDEBUG_LEVEL=0
 
 # custom matrix setup
 CUSTOM_MATRIX = yes
-SRC = matrix.c i2c.c
+SRC = matrix.c

keyboards/claw44/serial.c

@@ -17,7 +17,6 @@
 #include <stddef.h>
 #include <stdbool.h>
 #include "serial.h"
-//#include <pro_micro.h>
 
 #ifdef SOFT_SERIAL_PIN
 

keyboards/converter/usb_usb/ble/rules.mk

@@ -1,5 +1,4 @@
-BLUETOOTH = AdafruitBLE
-ADAFRUIT_BLE_ENABLE = yes
+# Processor frequency
 F_CPU = 8000000
 
 BOOTMAGIC_ENABLE = no      # Virtual DIP switch configuration(+1000)
@@ -19,5 +18,7 @@ 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 (+400)
+BLUETOOTH = AdafruitBLE
+ADAFRUIT_BLE_ENABLE = yes
 
 EXTRAFLAGS += -flto

keyboards/converter/usb_usb/hasu/rules.mk

@@ -1 +1,2 @@
+# Processor frequency
 F_CPU = 16000000

keyboards/converter/usb_usb/pro_micro/rules.mk

@@ -1 +1,2 @@
+# Processor frequency
 F_CPU = 8000000

keyboards/crkbd/serial.c

@@ -17,7 +17,6 @@
 #include <stddef.h>
 #include <stdbool.h>
 #include "serial.h"
-//#include <pro_micro.h>
 
 #ifdef SOFT_SERIAL_PIN
 

keyboards/donutcables/budget96/budget96.c

@@ -13,62 +13,9 @@
  * 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 "budget96.h"
 
-#ifdef BACKLIGHT_ENABLE
-#include "backlight.h"
-#endif
-#ifdef RGBLIGHT_ENABLE
-#include "rgblight.h"
-#endif
-
-#include <avr/pgmspace.h>
-
-#include "action_layer.h"
-#include "i2c_master.h"
-#include "quantum.h"
-
-__attribute__ ((weak))
-void matrix_scan_user(void) {
-}
-
-#ifdef RGBLIGHT_ENABLE
-extern rgblight_config_t rgblight_config;
-
-void rgblight_set(void) {
-    if (!rgblight_config.enable) {
-        for (uint8_t i = 0; i < RGBLED_NUM; i++) {
-            led[i].r = 0;
-            led[i].g = 0;
-            led[i].b = 0;
-        }
-    }
-
-    i2c_init();
-    i2c_transmit(0xb0, (uint8_t*)led, 3 * RGBLED_NUM, 100);
-}
-#endif
-
-void matrix_init_kb(void) {
-#ifdef RGBLIGHT_ENABLE
-    if (rgblight_config.enable) {
-        i2c_init();
-        i2c_transmit(0xb0, (uint8_t*)led, 3 * RGBLED_NUM, 100);
-    }
-#endif
-    // call user level keymaps, if any
-    matrix_init_user();
-}
-
-void matrix_scan_kb(void) {
-#ifdef RGBLIGHT_ENABLE
-    rgblight_task();
-#endif
-    matrix_scan_user();
-    /* Nothing else for now. */
-}
-
-
 void backlight_init_ports(void) {
     // initialize pins D0, D1, D4 and D6 as output
     setPinOutput(D0);
@@ -76,25 +23,25 @@ void backlight_init_ports(void) {
     setPinOutput(D4);
     setPinOutput(D6);
 
-     // turn RGB LEDs on
+    // turn backlight LEDs on
     writePinHigh(D0);
     writePinHigh(D1);
     writePinHigh(D4);
     writePinHigh(D6);
 }
 
- void backlight_set(uint8_t level) {
-	if (level == 0) {
-        // turn RGB LEDs off
+void backlight_set(uint8_t level) {
+    if (level == 0) {
+        // turn backlight LEDs off
         writePinLow(D0);
         writePinLow(D1);
         writePinLow(D4);
         writePinLow(D6);
-	} else {
-        // turn RGB LEDs on
+    } else {
+        // turn backlight LEDs on
         writePinHigh(D0);
         writePinHigh(D1);
         writePinHigh(D4);
         writePinHigh(D6);
-	}
- }
+    }
+}

keyboards/donutcables/budget96/rules.mk

@@ -1,18 +1,3 @@
-# Copyright 2017 Luiz Ribeiro <luizribeiro@gmail.com>
-#
-# 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/>.
-
 # MCU name
 MCU = atmega32a
 
@@ -34,9 +19,6 @@ CONSOLE_ENABLE = yes
 COMMAND_ENABLE = yes
 BACKLIGHT_ENABLE = yes
 RGBLIGHT_ENABLE = yes
-RGBLIGHT_CUSTOM_DRIVER = yes
+WS2812_DRIVER = i2c
 
 OPT_DEFS = -DDEBUG_LEVEL=0
-
-# custom matrix setup
-SRC = i2c_master.c

keyboards/ergoinu/matrix.c

@@ -174,18 +174,12 @@ uint8_t matrix_scan(void) {
   }else{
     matrix_slave_scan();
 
-//  if(serial_slave_DATA_CORRUPT()){
-//    TXLED0;
     int offset = (isLeftHand) ? ROWS_PER_HAND : 0;
 
     for (int i = 0; i < ROWS_PER_HAND; ++i) {
       matrix[offset+i] = serial_master_buffer[i];
     }
 
-//  }else{
-//    TXLED1;
-//  }
-
     matrix_scan_quantum();
   }
   return 1;

keyboards/eve/meteor/meteor.c

@@ -14,49 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "i2c_master.h"
-#include "quantum.h"
-
-#ifdef RGBLIGHT_ENABLE
-#include "rgblight.h"
-extern rgblight_config_t rgblight_config;
-
-void rgblight_set(void) {
-    if (!rgblight_config.enable) {
-        for (uint8_t i = 0; i < RGBLED_NUM; i++) {
-            led[i].r = 0;
-            led[i].g = 0;
-            led[i].b = 0;
-        }
-    }
-
-    i2c_init();
-    i2c_transmit(0xb0, (uint8_t*)led, 3 * RGBLED_NUM, 100);
-}
-#endif
-
-void matrix_init_kb(void) {
-#ifdef RGBLIGHT_ENABLE
-    if (rgblight_config.enable) {
-        i2c_init();
-        i2c_transmit(0xb0, (uint8_t*)led, 3 * RGBLED_NUM, 100);
-    }
-#endif
-    // call user level keymaps, if any
-    matrix_init_user();
-}
-
-void matrix_scan_kb(void) {
-#ifdef RGBLIGHT_ENABLE
-    rgblight_task();
-#endif
-    matrix_scan_user();
-    /* Nothing else for now. */
-}
-
-__attribute__ ((weak))
-void matrix_scan_user(void) {
-}
+#include "meteor.h"
 
 void backlight_init_ports(void) {
     // initialize pins D0, D1, D4 and D6 as output
@@ -73,17 +31,17 @@ void backlight_init_ports(void) {
 }
 
 void backlight_set(uint8_t level) {
-	if (level == 0) {
+    if (level == 0) {
         // turn backlight LEDs off
         writePinLow(D0);
         writePinLow(D1);
         writePinLow(D4);
         writePinLow(D6);
-	} else {
+    } else {
         // turn backlight LEDs on
         writePinHigh(D0);
         writePinHigh(D1);
         writePinHigh(D4);
         writePinHigh(D6);
-	}
+    }
 }

keyboards/eve/meteor/rules.mk

@@ -1,18 +1,3 @@
-# Copyright 2017 Luiz Ribeiro <luizribeiro@gmail.com>
-#
-# 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/>.
-
 # MCU name
 MCU = atmega32a
 
@@ -34,8 +19,6 @@ CONSOLE_ENABLE = yes
 COMMAND_ENABLE = yes
 BACKLIGHT_ENABLE = yes
 RGBLIGHT_ENABLE = no
-RGBLIGHT_CUSTOM_DRIVER = no
+WS2812_DRIVER = i2c
 
 OPT_DEFS = -DDEBUG_LEVEL=0
-
-QUANTUM_LIB_SRC = i2c_master.c

keyboards/exclusive/e6v2/le_bmc/le_bmc.c

@@ -13,49 +13,8 @@
  * 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 "rgblight.h"
-#include "i2c_master.h"
-#include "quantum.h"
 
-#ifdef RGBLIGHT_ENABLE
-extern rgblight_config_t rgblight_config;
-
-void rgblight_set(void) {
-    if (!rgblight_config.enable) {
-        for (uint8_t i = 0; i < RGBLED_NUM; i++) {
-            led[i].r = 0;
-            led[i].g = 0;
-            led[i].b = 0;
-        }
-    }
-
-    i2c_init();
-    i2c_transmit(0xb0, (uint8_t*)led, 3 * RGBLED_NUM, 100);
-}
-#endif
-
-void matrix_init_kb(void) {
-#ifdef RGBLIGHT_ENABLE
-    if (rgblight_config.enable) {
-        i2c_init();
-        i2c_transmit(0xb0, (uint8_t*)led, 3 * RGBLED_NUM, 100);
-    }
-#endif
-    // call user level keymaps, if any
-    matrix_init_user();
-}
-
-void matrix_scan_kb(void) {
-#ifdef RGBLIGHT_ENABLE
-    rgblight_task();
-#endif
-    matrix_scan_user();
-    /* Nothing else for now. */
-}
-
-__attribute__ ((weak))
-void matrix_scan_user(void) {
-}
+#include "le_bmc.h"
 
 void backlight_init_ports(void) {
     // initialize pins D0, D1, D4 and D6 as output
@@ -72,17 +31,17 @@ void backlight_init_ports(void) {
 }
 
 void backlight_set(uint8_t level) {
-	if (level == 0) {
+    if (level == 0) {
         // turn backlight LEDs off
         writePinLow(D0);
         writePinLow(D1);
         writePinLow(D4);
         writePinLow(D6);
-	} else {
+    } else {
         // turn backlight LEDs on
         writePinHigh(D0);
         writePinHigh(D1);
         writePinHigh(D4);
         writePinHigh(D6);
-	}
-}
+    }
+}

keyboards/exclusive/e6v2/le_bmc/rules.mk

@@ -24,7 +24,7 @@ SLEEP_LED_ENABLE = no       # Breathing sleep LED during USB suspend
 # if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
 NKRO_ENABLE = no            # USB Nkey Rollover
 BACKLIGHT_ENABLE = no       # Enable keyboard backlight functionality on B7 by default
-RGBLIGHT_CUSTOM_DRIVER = yes
+WS2812_DRIVER = i2c
 RGBLIGHT_ENABLE = yes        # Enable keyboard RGB underglow
 MIDI_ENABLE = no            # MIDI support (+2400 to 4200, depending on config)
 UNICODE_ENABLE = no         # Unicode
@@ -34,4 +34,3 @@ FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
 HD44780_ENABLE = no 		# Enable support for HD44780 based LCDs (+400)
 
 OPT_DEFS = -DDEBUG_LEVEL=0
-SRC += i2c_master.c

keyboards/exclusive/e6v2/oe_bmc/oe_bmc.c

@@ -13,57 +13,8 @@
  * 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 "oe_bmc.h"
-#include "rgblight.h"
-#include "i2c_master.h"
-
-void matrix_init_kb(void) {
-	// put your keyboard start-up code here
-	// runs once when the firmware starts up
-
-	matrix_init_user();
-}
-
-void matrix_scan_kb(void) {
-	// put your looping keyboard code here
-	// runs every cycle (a lot)
-
-	matrix_scan_user();
-}
-
-bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
-	// put your per-action keyboard code here
-	// runs for every action, just before processing by the firmware
-
-	return process_record_user(keycode, record);
-}
-
-void led_set_kb(uint8_t usb_led) {
-	// put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
-
-	led_set_user(usb_led);
-}
-
-#ifdef RGBLIGHT_ENABLE
-extern rgblight_config_t rgblight_config;
-
-void rgblight_set(void) {
-    if (!rgblight_config.enable) {
-        for (uint8_t i = 0; i < RGBLED_NUM; i++) {
-            led[i].r = 0;
-            led[i].g = 0;
-            led[i].b = 0;
-        }
-    }
-
-    i2c_init();
-    i2c_transmit(0xb0, (uint8_t*)led, 3 * RGBLED_NUM, 100);
-}
-#endif
-
-__attribute__ ((weak))
-void matrix_scan_user(void) {
-}
 
 void backlight_init_ports(void) {
     // initialize pins D0, D1, D4 and D6 as output
@@ -72,7 +23,7 @@ void backlight_init_ports(void) {
     setPinOutput(D4);
     setPinOutput(D6);
 
-    // turn RGB LEDs on
+    // turn backlight LEDs on
     writePinHigh(D0);
     writePinHigh(D1);
     writePinHigh(D4);
@@ -80,17 +31,17 @@ void backlight_init_ports(void) {
 }
 
 void backlight_set(uint8_t level) {
-	if (level == 0) {
-        // turn RGB LEDs off
+    if (level == 0) {
+        // turn backlight LEDs off
         writePinLow(D0);
         writePinLow(D1);
         writePinLow(D4);
         writePinLow(D6);
-	} else {
-        // turn RGB LEDs on
+    } else {
+        // turn backlight LEDs on
         writePinHigh(D0);
         writePinHigh(D1);
         writePinHigh(D4);
         writePinHigh(D6);
-	}
+    }
 }

keyboards/exclusive/e6v2/oe_bmc/rules.mk

@@ -24,7 +24,7 @@ SLEEP_LED_ENABLE = no       # Breathing sleep LED during USB suspend
 # if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
 NKRO_ENABLE = no            # USB Nkey Rollover
 BACKLIGHT_ENABLE = no       # Enable keyboard backlight functionality on B7 by default
-RGBLIGHT_CUSTOM_DRIVER = yes
+WS2812_DRIVER = i2c
 RGBLIGHT_ENABLE = yes        # Enable keyboard RGB underglow
 MIDI_ENABLE = no            # MIDI support (+2400 to 4200, depending on config)
 UNICODE_ENABLE = no         # Unicode
@@ -34,4 +34,3 @@ FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
 HD44780_ENABLE = no 		# Enable support for HD44780 based LCDs (+400)
 
 OPT_DEFS = -DDEBUG_LEVEL=0
-SRC += i2c_master.c

keyboards/exent/exent.c

@@ -15,76 +15,3 @@
  */
 
 #include "exent.h"
-
-#ifdef RGBLIGHT_ENABLE
-
-#    include <string.h>
-#    include "i2c_master.h"
-#    include "rgblight.h"
-
-extern rgblight_config_t rgblight_config;
-
-void matrix_init_kb(void) {
-    i2c_init();
-    // call user level keymaps, if any
-    matrix_init_user();
-}
-
-// custom RGB driver
-void rgblight_set(void) {
-    if (!rgblight_config.enable) {
-        memset(led, 0, 3 * RGBLED_NUM);
-    }
-
-    i2c_transmit(0xb0, (uint8_t*)led, 3 * RGBLED_NUM, 100);
-}
-
-bool rgb_init = false;
-
-void matrix_scan_kb(void) {
-    // if LEDs were previously on before poweroff, turn them back on
-    if (rgb_init == false && rgblight_config.enable) {
-        i2c_transmit(0xb0, (uint8_t*)led, 3 * RGBLED_NUM, 100);
-        rgb_init = true;
-    }
-
-    rgblight_task();
-    matrix_scan_user();
-}
-
-#endif
-
-// Optional override functions below.
-// You can leave any or all of these undefined.
-// These are only required if you want to perform custom actions.
-
-/*
-
-void matrix_init_kb(void) {
-  // put your keyboard start-up code here
-  // runs once when the firmware starts up
-
-  matrix_init_user();
-}
-
-void matrix_scan_kb(void) {
-  // put your looping keyboard code here
-  // runs every cycle (a lot)
-
-  matrix_scan_user();
-}
-
-bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
-  // put your per-action keyboard code here
-  // runs for every action, just before processing by the firmware
-
-  return process_record_user(keycode, record);
-}
-
-void led_set_kb(uint8_t usb_led) {
-  // put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
-
-  led_set_user(usb_led);
-}
-
-*/

keyboards/exent/rules.mk

@@ -19,10 +19,8 @@ CONSOLE_ENABLE = yes
 COMMAND_ENABLE = yes
 BACKLIGHT_ENABLE = no
 RGBLIGHT_ENABLE = yes
-RGBLIGHT_CUSTOM_DRIVER = yes
+WS2812_DRIVER = i2c
 
 OPT_DEFS = -DDEBUG_LEVEL=0
 
-SRC += i2c_master.c
-
 LAYOUTS = 65_ansi 65_iso

keyboards/facew/facew.c

@@ -16,51 +16,31 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "facew.h"
-#ifdef BACKLIGHT_ENABLE
-#include "backlight.h"
-#endif
-#ifdef RGBLIGHT_ENABLE
-#include "rgblight.h"
-#endif
-
-#include <avr/pgmspace.h>
-
-#include "action_layer.h"
-#include "i2c_master.h"
-#include "quantum.h"
-
-#ifdef RGBLIGHT_ENABLE
-extern rgblight_config_t rgblight_config;
-
-void rgblight_set(void) {
-    if (!rgblight_config.enable) {
-        for (uint8_t i = 0; i < RGBLED_NUM; i++) {
-            led[i].r = 0;
-            led[i].g = 0;
-            led[i].b = 0;
-        }
-    }
-
-    i2c_init();
-    i2c_transmit(0xb0, (uint8_t*)led, 3 * RGBLED_NUM, 100);
-}
-#endif
-
-__attribute__ ((weak))
-void matrix_scan_user(void) {
-}
 
 void backlight_init_ports(void) {
-	DDRD |= (1<<0 | 1<<1 | 1<<4 | 1<<6);
-	PORTD &= ~(1<<0 | 1<<1 | 1<<4 | 1<<6);
+	setPinOutput(D0);
+	setPinOutput(D1);
+	setPinOutput(D4);
+	setPinOutput(D6);
+
+	writePinLow(D0);
+	writePinLow(D1);
+	writePinLow(D4);
+	writePinLow(D6);
 }
 
 void backlight_set(uint8_t level) {
 	if (level == 0) {
 		// Turn out the lights
-		PORTD &= ~(1<<0 | 1<<1 | 1<<4 | 1<<6);
+		writePinLow(D0);
+		writePinLow(D1);
+		writePinLow(D4);
+		writePinLow(D6);
 	} else {
 		// Turn on the lights
-		PORTD |= (1<<0 | 1<<1 | 1<<4 | 1<<6);
+		writePinHigh(D0);
+		writePinHigh(D1);
+		writePinHigh(D4);
+		writePinHigh(D6);
 	}
 }

keyboards/facew/rules.mk

@@ -1,18 +1,3 @@
-# Copyright 2017 Luiz Ribeiro <luizribeiro@gmail.com>
-#
-# 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/>.
-
 # MCU name
 MCU = atmega32a
 
@@ -34,11 +19,8 @@ CONSOLE_ENABLE = yes
 COMMAND_ENABLE = yes
 BACKLIGHT_ENABLE = yes
 RGBLIGHT_ENABLE = yes
-RGBLIGHT_CUSTOM_DRIVER = yes
+WS2812_DRIVER = i2c
 
 OPT_DEFS = -DDEBUG_LEVEL=0
 
-# custom matrix setup
-SRC = i2c_master.c
-
 LAYOUTS = 60_ansi

keyboards/fortitude60/serial.c

@@ -17,7 +17,6 @@
 #include <stddef.h>
 #include <stdbool.h>
 #include "serial.h"
-//#include <pro_micro.h>
 
 #ifdef SOFT_SERIAL_PIN