[Docs] Spanish translation (#7068)

* add all translation docs to translating.md * Adding Spanish folder and README.md * Adding Spanish to the langs file * Adding a Spanish summary file * Small corrections on the Spanish README file * Adding Spanish newbs.md * Translate some newbs documentation * Adding the translated newbs getting started file * Adding the building firmware file * Adding a translated building firmware with configurator file * Adding the flashing guide * Adding the newbs_testing_debugging file * Apply suggestions from code review * QMK Configurator -> Configurador QMK Co-Authored-By: Karey Higuera <karey.higuera@gmail.com>
4 years ago · bc7f1dd296
--- a/docs/_langs.md
+++ b/docs/_langs.md
@ -1,6 +1,7 @@
 - Translations
  - [:uk: English](/)
  - [:cn: 中文](/zh-cn/)
  - [:es: Español](/es/)
  - [:fr: Français](/fr-fr/)
  - [:he: עברית](/he-il/)
  - [:ru: Русский](/ru-ru/)
--- a/docs/es/README.md
+++ b/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).
--- a/docs/es/_summary.md
+++ b/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)
--- a/docs/es/becoming_a_qmk_collaborator.md
+++ b/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!
--- a/docs/es/newbs.md
+++ b/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.
--- a/docs/es/newbs_best_practices.md
+++ b/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 &mdash; cuando dos o más usuarios han editado la misma parte de un archivo al mismo tiempo &mdash; 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.
--- a/docs/es/newbs_building_firmware.md
+++ b/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.
--- a/docs/es/newbs_building_firmware_configurator.md
+++ b/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)
--- a/docs/es/newbs_flashing.md
+++ b/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.
--- a/docs/es/newbs_getting_started.md
+++ b/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).
--- a/docs/es/newbs_learn_more_resources.md
+++ b/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)
--- a/docs/es/newbs_testing_debugging.md
+++ b/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
 ```
--- a/docs/index.html
+++ b/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!'
        },