Merge remote-tracking branch 'upstream/master'

.travis.yml

@@ -1,6 +1,5 @@
 os: linux
 dist: trusty
-sudo: required
 group: edge
 language: c
 branches:

common_features.mk

@@ -229,13 +229,32 @@ ifeq ($(strip $(LCD_ENABLE)), yes)
     CIE1931_CURVE = yes
 endif
 
-ifeq ($(strip $(BACKLIGHT_ENABLE)), yes)
+# backward compat
+ifeq ($(strip $(BACKLIGHT_CUSTOM_DRIVER)), yes)
+    BACKLIGHT_ENABLE = custom
+endif
+
+VALID_BACKLIGHT_TYPES := yes custom
+
+BACKLIGHT_ENABLE ?= no
+ifneq ($(strip $(BACKLIGHT_ENABLE)), no)
+    ifeq ($(filter $(BACKLIGHT_ENABLE),$(VALID_BACKLIGHT_TYPES)),)
+        $(error BACKLIGHT_ENABLE="$(BACKLIGHT_ENABLE)" is not a valid backlight type)
+    endif
+
     ifeq ($(strip $(VISUALIZER_ENABLE)), yes)
         CIE1931_CURVE = yes
     endif
-    ifeq ($(strip $(BACKLIGHT_CUSTOM_DRIVER)), yes)
+
+    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
 
 ifeq ($(strip $(CIE1931_CURVE)), yes)

docs/_langs.md

@@ -1,3 +1,4 @@
 - Translations
   - [:uk: English](/)
   - [:cn: 中文](/zh-cn/)
+  - [:fr: Français](/fr-fr/)

docs/cli.md

@@ -105,6 +105,16 @@ This command lets you configure the behavior of QMK. For the full `qmk config` d
 qmk config [-ro] [config_token1] [config_token2] [...] [config_tokenN]
 ```
 
+## `qmk docs`
+
+This command starts a local HTTP server which you can use for browsing or improving the docs. Default port is 8936.
+
+**Usage**:
+
+```
+qmk docs [-p PORT]
+```
+
 ## `qmk doctor`
 
 This command examines your environment and alerts you to potential build or flash problems.
@@ -115,6 +125,16 @@ This command examines your environment and alerts you to potential build or flas
 qmk doctor
 ```
 
+## `qmk list_keyboards`
+
+This command lists all the keyboards currently defined in `qmk_firmware`
+
+**Usage**:
+
+```
+qmk list_keyboards
+```
+
 ## `qmk new-keymap`
 
 This command creates a new keymap based on a keyboard's existing default keymap.

docs/contributing.md

@@ -63,11 +63,11 @@ Most of our style is pretty easy to pick up on. If you are familiar with either
 
 We have a few different types of changes in QMK, each requiring a different level of rigor. We'd like you to keep the following guidelines in mind no matter what type of change you're making.
 
-* Separate PR's into logical units. For example, do not submit one PR covering two separate features, instead submit a separate PR for each feature.
+* Separate PRs into logical units. For example, do not submit one PR covering two separate features, instead submit a separate PR for each feature.
 * Check for unnecessary whitespace with `git diff --check` before committing.
 * Make sure your code change actually compiles.
-  * Keymaps: Make sure that `make keyboard:your_new_keymap` does not return an error
+  * Keymaps: Make sure that `make keyboard:your_new_keymap` does not return any errors.
-  * Keyboards: Make sure that `make keyboard:all` does not return any errors
+  * Keyboards: Make sure that `make keyboard:all` does not return any errors.
   * Core: Make sure that `make all` does not return any errors.
 * Make sure commit messages are understandable on their own. You should put a short description (no more than 70 characters) on the first line, the second line should be empty, and on the 3rd and later lines you should describe your commit in detail, if required. Example:
 
@@ -79,6 +79,8 @@ The kerpleplork was intermittently failing with error code 23. The root cause wa
 Limited experimentation on the devices I have available shows that 7 is high enough to avoid confusing the kerpleplork, but I'd like to get some feedback from people with ARM devices to be sure.
 ```
 
+!> **IMPORTANT:** If you would like to contribute a bugfix or improvement to user code, such as non-default keymaps, userspace and layouts, be sure to tag the original submitter of the code in your PR. Many users, regardless of skill level with Git and GitHub, may be confused or frustrated at their code being modified without their knowledge.
+
 ## Documentation
 
 Documentation is one of the easiest ways to get started contributing to QMK. Finding places where the documentation is wrong or incomplete and fixing those is easy! We also very badly need someone to edit our documentation, so if you have editing skills but aren't sure where or how to jump in please [reach out for help](#where-can-i-go-for-help)!

docs/faq_general.md

@@ -4,10 +4,6 @@
 
 [QMK](https://github.com/qmk), short for Quantum Mechanical Keyboard, is a group of people building tools for custom keyboards. We started with the [QMK firmware](https://github.com/qmk/qmk_firmware), a heavily modified fork of [TMK](https://github.com/tmk/tmk_keyboard).
 
-### Why the Name Quantum?
-
-<!-- FIXME -->
-
 ## What Differences Are There Between QMK and TMK?
 
 TMK was originally designed and implemented by [Jun Wako](https://github.com/tmk). QMK started as [Jack Humbert](https://github.com/jackhumbert)'s fork of TMK for the Planck. After a while Jack's fork had diverged quite a bit from TMK, and in 2015 Jack decided to rename his fork to QMK.

docs/feature_backlight.md

@@ -1,6 +1,8 @@
 # Backlighting
 
-Many keyboards support backlit keys by way of individual LEDs placed through or underneath the keyswitches. QMK is able to control the brightness of these LEDs by switching them on and off rapidly in a certain ratio, a technique known as *Pulse Width Modulation*, or PWM. By altering the duty cycle of the PWM signal, it creates the illusion of dimming.
+Many keyboards support backlit keys by way of individual LEDs placed through or underneath the keyswitches. This feature is distinct from both the [RGB underglow](feature_rgblight.md) and [RGB matrix](feature_rgb_matrix.md) features as it usually allows for only a single colour per switch, though you can obviously install multiple different single coloured LEDs on a keyboard.
+
+QMK is able to control the brightness of these LEDs by switching them on and off rapidly in a certain ratio, a technique known as *Pulse Width Modulation*, or PWM. By altering the duty cycle of the PWM signal, it creates the illusion of dimming.
 
 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.
 
@@ -12,9 +14,8 @@ Most keyboards have backlighting enabled by default if they support it, but if i
 BACKLIGHT_ENABLE = yes
 ```
 
-You should then be able to use the keycodes below to change the backlight level.
-
 ## Keycodes
+Once enabled the following keycodes below can be used to change the backlight level.
 
 |Key      |Description                               |
 |---------|------------------------------------------|
@@ -26,9 +27,9 @@ You should then be able to use the keycodes below to change the backlight level.
 |`BL_DEC` |Decrease the backlight level              |
 |`BL_BRTG`|Toggle backlight breathing                |
 
-## Caveats
+## AVR driver
 
-This feature is distinct from both the [RGB underglow](feature_rgblight.md) and [RGB matrix](feature_rgb_matrix.md) features as it usually allows for only a single colour per switch, though you can obviously use multiple different coloured LEDs on a keyboard.
+### Caveats
 
 Hardware PWM is supported according to the following table:
 
@@ -58,9 +59,9 @@ All other pins will use software PWM. If the [Audio](feature_audio.md) feature i
 
 When both timers are in use for Audio, the backlight PWM will not use a hardware timer, but will instead be triggered during the matrix scan. In this case, breathing is not supported, and the backlight might flicker, because the PWM computation may not be called with enough timing precision.
 
-## Configuration
+### AVR Configuration
 
-To change the behaviour of the backlighting, `#define` these in your `config.h`:
+To change the behavior of the backlighting, `#define` these in your `config.h`:
 
 |Define               |Default      |Description                                                                                                  |
 |---------------------|-------------|-------------------------------------------------------------------------------------------------------------|
@@ -72,14 +73,14 @@ To change the behaviour of the backlighting, `#define` these in your `config.h`:
 |`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
+### 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.
 
-## Multiple backlight pins
+### 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.
@@ -87,13 +88,13 @@ This feature allows to set for instance the Caps Lock LED (or any other controll
 
 To activate multiple backlight pins, you need to add something like this to your user `config.h`:
 
-~~~c
+```c
 #define BACKLIGHT_LED_COUNT 2
 #undef BACKLIGHT_PIN
 #define BACKLIGHT_PINS { F5, B2 }
-~~~
+```
 
-## Hardware PWM Implementation
+### Hardware PWM Implementation
 
 When using the supported pins for backlighting, QMK will use a hardware timer configured to output a PWM signal. This timer will count up to `ICRx` (by default `0xFFFF`) before resetting to 0.
 The desired brightness is calculated and stored in the `OCRxx` register. When the counter reaches this value, the backlight pin will go low, and is pulled high again when the counter resets.
@@ -102,7 +103,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
+### Software 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.
@@ -111,6 +112,29 @@ In this way `OCRxx` essentially controls the duty cycle of the LEDs, and thus th
 
 The breathing effect is the same as in the hardware PWM implementation.
 
+## ARM Driver
+
+### Caveats
+
+Currently only hardware PWM is supported, and does not provide automatic configuration.
+
+?> STMF072 support is being investigated.
+
+### ARM Configuration
+
+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_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
 
 |Function  |Description                                                |

docs/feature_hd44780.md

@@ -6,7 +6,8 @@ You can enable support for HD44780 Displays by setting the `HD44780_ENABLE` flag
 
 ## Configuration
 
-You will need to configure the pins used by your display and its number of lines and collumn in your keyboards `config.h`.
+You will need to configure the pins used by your display, and its number of lines and columns in your keyboard's `config.h`.
+
 
 Uncomment the section labled HD44780 and change the parameters as needed.
 ````
@@ -40,7 +41,7 @@ Should you need to configure other properties you can copy them from `quantum/hd
 
 ## Usage 
 
-To initialize your display call lcd_init() with one of these parameters:
+To initialize your display, call `lcd_init()` with one of these parameters:
 ````
 LCD_DISP_OFF             : display off
 LCD_DISP_ON              : display on, cursor off
@@ -53,4 +54,4 @@ To do so call `lcd_clrsrc()`.
 
 To now print something to your Display you first call `lcd_gotoxy(column, line)`. To go to the start of the first line you would call `lcd_gotoxy(0, 0)` and then print a string with `lcd_puts("example string")`.
 
-There are more posible methods to control the display. [For in depth documentation please visit the linked page.](http://homepage.hispeed.ch/peterfleury/doxygen/avr-gcc-libraries/group__pfleury__lcd.html)
+There are more methods available to control the display. [For in depth documentation please visit the linked page.](http://homepage.hispeed.ch/peterfleury/doxygen/avr-gcc-libraries/group__pfleury__lcd.html)

docs/feature_ps2_mouse.md

@@ -149,7 +149,7 @@ In your keyboard config.h:
 
 #### PS/2 Mouse Features
 
-These enable settings supported by the PS/2 mouse protocol: http://www.computer-engineering.org/ps2mouse/
+These enable settings supported by the PS/2 mouse protocol.
 
 ```
 /* Use remote mode instead of the default stream mode (see link) */
@@ -202,7 +202,7 @@ Note: you can also use `ps2_mouse_set_resolution` for the same effect (not suppo
 #### Scroll Button
 
 If you're using a trackpoint, you will likely want to be able to use it for scrolling.
-Its possible to enable a "scroll button/s" that when pressed will cause the mouse to scroll instead of moving.
+It's possible to enable a "scroll button/s" that when pressed will cause the mouse to scroll instead of moving.
 To enable the feature, you must set a scroll button mask as follows:
 
 ```

docs/feature_tap_dance.md

@@ -422,7 +422,7 @@ Tap Dance can be used to mimic MO(layer) and TG(layer) functionality. For this e
 
 The first step is to include the following code towards the beginning of your `keymap.c`:
 
-```
+```c
 typedef struct {
   bool is_press_action;
   int state;
@@ -452,36 +452,20 @@ void ql_reset (qk_tap_dance_state_t *state, void *user_data);
 int active_layer;
 ```
 
-The above code is similar to that used in previous examples. The one point to note is that you need to declare a variable to keep track of what layer is currently the active layer. We'll see why shortly.
-
 Towards the bottom of your `keymap.c`, include the following code:
 
-```
+```c
-//Update active_layer
-uint32_t layer_state_set_user(uint32_t state) {
-  switch (biton32(state)) {
-    case 1:
-      active_layer = 1;
-      break;
-    case 2:
-      active_layer = 2;
-      break;
-    case 3:
-      active_layer = 3;
-      break;
-    default:
-      active_layer = 0;
-      break;
-  }
-  return state;
-}
-
 //Determine the current tap dance state
 int cur_dance (qk_tap_dance_state_t *state) {
   if (state->count == 1) {
-    if (!state->pressed) {return SINGLE_TAP;}
+    if (!state->pressed) {
-    else return SINGLE_HOLD;
+      return SINGLE_TAP;
-  } else if (state->count == 2) {return DOUBLE_TAP;}
+    } else {
+      return SINGLE_HOLD;
+    }
+  } else if (state->count == 2) {
+    return DOUBLE_TAP;
+  }
   else return 8;
 }
 
@@ -495,16 +479,30 @@ static tap ql_tap_state = {
 void ql_finished (qk_tap_dance_state_t *state, void *user_data) {
   ql_tap_state.state = cur_dance(state);
   switch (ql_tap_state.state) {
-    case SINGLE_TAP: tap_code(KC_QUOT); break;
+    case SINGLE_TAP: 
-    case SINGLE_HOLD: layer_on(_MY_LAYER); break;
+      tap_code(KC_QUOT); 
+      break;
+    case SINGLE_HOLD: 
+      layer_on(_MY_LAYER); 
+      break;
     case DOUBLE_TAP: 
-      if (active_layer==_MY_LAYER) {layer_off(_MY_LAYER);}
+      //check to see if the layer is already set
-      else layer_on(_MY_LAYER);
+      if (layer_state_is(_MY_LAYER)) {
+        //if already set, then switch it off
+        layer_off(_MY_LAYER);
+      } else { 
+        //if not already set, then switch the layer on
+        layer_on(_MY_LAYER);
+      }
+      break;
   }
 }
 
 void ql_reset (qk_tap_dance_state_t *state, void *user_data) {
-  if (ql_tap_state.state==SINGLE_HOLD) {layer_off(_MY_LAYER);}
+  //if the key was held down and now is released then switch off the layer
+  if (ql_tap_state.state==SINGLE_HOLD) {
+    layer_off(_MY_LAYER);
+  }
   ql_tap_state.state = 0;
 }
 
@@ -514,7 +512,7 @@ qk_tap_dance_action_t tap_dance_actions[] = {
 };
 ```
 
-The is where the real logic of our tap dance key gets worked out. Since `layer_state_set_user()` is called on any layer switch, we use it to update `active_layer`. Our example is assuming that your `keymap.c` includes 4 layers, so adjust the switch statement here to fit your actual number of layers.
+The above code is similar to that used in previous examples. The one point to note is that we need to be able to check which layers are active at any time so we can toggle them if needed. To do this we use the `layer_state_is( layer )` function which returns `true` if the given `layer` is active.
 
 The use of `cur_dance()` and `ql_tap_state` mirrors the above examples.
 

docs/fr-FR/README.md

@@ -0,0 +1,32 @@
+# Quantum Mechanical Keyboard Firmware
+
+[![Version courante](https://img.shields.io/github/tag/qmk/qmk_firmware.svg)](https://github.com/qmk/qmk_firmware/tags)
+[![Statut du 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)
+[![Statut de la doc](https://img.shields.io/badge/docs-ready-orange.svg)](https://docs.qmk.fm)
+[![Contributeurs Github](https://img.shields.io/github/contributors/qmk/qmk_firmware.svg)](https://github.com/qmk/qmk_firmware/pulse/monthly)
+[![Forks Github](https://img.shields.io/github/forks/qmk/qmk_firmware.svg?style=social&label=Fork)](https://github.com/qmk/qmk_firmware/)
+
+## Qu'est ce que QMK Firmware ?
+
+QMK (*Quantum Mechanical Keyboard*) est une communauté open source qui maintient le firmware QMK, la QMK Toolbox (*Boite à outil*), qmk.fm et leurs documentations. QMK Firmware est un firmware dédié aux claviers qui est basé sur [tmk\_keyboard](http://github.com/tmk/tmk_keyboard). Il offre des fonctionnalités très utiles pour les contrôleurs Atmel AVR, et, plus spécifiquement pour [les produits d'OLKB](http://olkb.com), le clavier [ErgoDox EZ](http://www.ergodox-ez.com), et pour les [produits Clueboard](http://clueboard.co/). Il prend désormais aussi en charge les processeurs ARM qui utilisent ChibiOS. Vous pouvez l'utiliser pour contrôler un clavier personnalisé soudé à la main ou alors sur un clavier avec un PCB personnalisé.
+
+## Comment l'obtenir
+
+Si vous souhaitez contribuer à une disposition de clavier (keymap), ou à des fonctionnalités de QMK alors le plus simple est de [forker le dépôt avec Github](https://github.com/qmk/qmk_firmware#fork-destination-box) puis cloner le dépôt localement pour y faire des changements. Vous pourrez pousser vos changements sur github puis ouvrir un [Pull Request](https://github.com/qmk/qmk_firmware/pulls) depuis votre fork Github.
+
+Sinon, vous pouvez aussi le télécharger directement en ([zip](https://github.com/qmk/qmk_firmware/zipball/master), [tar](https://github.com/qmk/qmk_firmware/tarball/master)), ou le cloner avec git en ssh (`git@github.com:qmk/qmk_firmware.git`), ou https (`https://github.com/qmk/qmk_firmware.git`).
+
+## Comment le compiler
+
+Avant d'être prêt à compiler vous allez devoir [installer un environnement](getting_started_build_tools.md) pour les développements AVR et/ou ARM. Une fois ceci fait, vous pourrez utiliser la commande `make` pour compiler le clavier et la disposition avec une commande de ce type :
+
+    make planck/rev4:default
+
+Cette commande compilera la révision `rev4` du clavier `planck` avec la disposition `default`. Notez que tous les claviers n'ont pas forcément de révisions (aussi appelées sous-projects ou dossiers, ou en en Anglais « subprojects » ou « folder »). Cette option peut donc être omise :
+
+    make preonic:default
+
+## Comment le personnaliser
+
+QMK a beaucoup de [fonctionnalités](features.md) à explorer, et [une documentation](http://docs.qmk.fm) très abondante que vous pourrez parcourir. La plupart des fonctionnalités vous permettrons de modifier vos [dispositions](keymap.md) (keymaps) et de changer [les codes de caractères](keycodes.md) (keycodes).

docs/fr-FR/_summary.md

@@ -0,0 +1,125 @@
+**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)
+
+* [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)
+
+**En Anglais**
+
+* [Changements non rétro-compatibles](breaking_changes.md)
+  * [30 Aout 2019](ChangeLog/20190830.md)
+
+* [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)
+  * [Commandes de compilations](getting_started_make_guide.md)
+  * [Flasher les firmwares](fr-fr/flashing.md)
+  * [Personnaliser les fonctionnalités](custom_quantum_functions.md)
+  * [Aperçu des fonctionnalités des dispositions](keymap.md)
+
+* [Hardware](hardware.md)
+  * [Processeurs AVR](hardware_avr.md)
+  * [Pilotes / Drivers](hardware_drivers.md)
+
+* Réferences
+  * [Lignes de conduite des claviers](hardware_keyboard_guidelines.md)
+  * [Options de configurations](config_options.md)
+  * [Keycodes / Codes des caractères](keycodes.md)
+  * [Conventions de codage - C](coding_conventions_c.md)
+  * [Conventions de codage - Python](coding_conventions_python.md)
+  * [Meilleurs pratiques sur la documentation](documentation_best_practices.md)
+  * [Modèles de documentation](documentation_templates.md)
+  * [Glossaire](reference_glossary.md)
+  * [Tests unitaires](unit_testing.md)
+  * [Fonctions utiles](ref_functions.md)
+  * [Support de configuration](reference_configurator_support.md)
+  * [Format du fichier info.json](reference_info_json.md)
+  * [Développer la CLI en Python](cli_development.md)
+
+* [Fonctionnalités](features.md)
+  * [Keycodes basiques](keycodes_basic.md)
+  * [Touches utilisées avec Shift (US ANSI)](keycodes_us_ansi_shifted.md)
+  * [Keycodes quantiques](quantum_keycodes.md)
+  * [Keycodes avancés](feature_advanced_keycodes.md)
+  * [Fonctionnalités audio](feature_audio.md)
+  * [Majuscule automatique](feature_auto_shift.md)
+  * [Rétroéclairage](feature_backlight.md)
+  * [Bluetooth](feature_bluetooth.md)
+  * [Bootmagic](feature_bootmagic.md)
+  * [Combos](feature_combo.md)
+  * [Commande](feature_command.md)
+  * [API anti-rebond](feature_debounce_type.md)
+  * [DIP Switch](feature_dip_switch.md)
+  * [Macros dynamiques](feature_dynamic_macros.md)
+  * [Interrupteurs rotatifs](feature_encoders.md)
+  * [Grave Escape](feature_grave_esc.md)
+  * [Retour haptique](feature_haptic_feedback.md)
+  * [Contrôleur LCD HD44780](feature_hd44780.md)
+  * [Touche à verrou / Lock-key](feature_key_lock.md)
+  * [Dispositions / layouts](feature_layouts.md)
+  * [Touche leader](feature_leader_key.md)
+  * [Matrice LED](feature_led_matrix.md)
+  * [Macros](feature_macros.md)
+  * [Boutons de souris](feature_mouse_keys.md)
+  * [Pilotes / Drivers OLED](feature_oled_driver.md)
+  * [Touche one-shot](feature_advanced_keycodes.md#one-shot-keys)
+  * [Périphériques de pointage](feature_pointing_device.md)
+  * [Souris PS/2](feature_ps2_mouse.md)
+  * [Éclairage RGB](feature_rgblight.md)
+  * [Matrice RGB](feature_rgb_matrix.md)
+  * [Space Cadet](feature_space_cadet.md)
+  * [Claviers scindés / splittés](feature_split_keyboard.md)
+  * [Stenographie](feature_stenography.md)
+  * [Inversion des mains](feature_swap_hands.md)
+  * [Tap Dance](feature_tap_dance.md)
+  * [Terminale](feature_terminal.md)
+  * [Imprimante thermique](feature_thermal_printer.md)
+  * [Caractères unicodes](feature_unicode.md)
+  * [Dossier utilisateur](feature_userspace.md)
+  * [Velocikey](feature_velocikey.md)
+
+* Pour les makers et les bricoleurs
+  * [Guide des claviers soudés à la main](hand_wire.md)
+  * [Guide de flash de l’ISP](isp_flashing_guide.md)
+  * [Guide du débogage ARM](arm_debugging.md)
+  * [Drivers i2c](i2c_driver.md)
+  * [Contrôles des GPIO](internals_gpio_control.md)
+  * [Conversion en Proton C](proton_c_conversion.md)
+
+* Pour aller plus loin
+  * [Comment fonctionnent les claviers](how_keyboards_work.md)
+  * [Comprendre QMK](understanding_qmk.md)
+
+* Autres sujets
+  * [Utiliser Eclipse avec QMK](other_eclipse.md)
+  * [Utiliser VSCode avec QMK](other_vscode.md)
+  * [Support](support.md)
+  * [Comment ajouter des traductions](translating.md)
+
+* À l’intérieur de QMK (En cours de documentation)
+  * [Définitions](internals_defines.md)
+  * [Input Callback Reg](internals_input_callback_reg.md)
+  * [Appareils Midi](internals_midi_device.md)
+  * [Installation d’un appareil Midi](internals_midi_device_setup_process.md)
+  * [Utilitaires Midi](internals_midi_util.md)
+  * [Fonctions Midi](internals_send_functions.md)
+  * [Outils Sysex](internals_sysex_tools.md)

docs/fr-FR/cli.md

@@ -0,0 +1,146 @@
+# La CLI de QMK
+
+Cette page décrit comment configurer et utiliser la CLI QMK.
+
+# Vue d'ensemble
+
+La CLI de QMK permet de simplifier la compilation et l'intéraction avec les clavier QMK. Nous avons définis plusieurs commandes pour simplifier et rationaliser les tâches telles qu'obtenir et compiler le firmware QMK, créer de nouvelles keymaps, et plus.
+
+* [CLI globale](#global-cli)
+* [CLI locale](#local-cli)
+* [Les commandes CLI](#cli-commands)
+
+# Pré-requis
+
+La CLI nécessite Python 3.5 ou plus récent. Nous essayons de limiter le nombre de pré-requis, mais vous allez aussi devoir installer les paquets listés dans le fichier [`requirements.txt`](https://github.com/qmk/qmk_firmware/blob/master/requirements.txt).
+
+# CLI globale
+
+QMK met à disposition une CLI installable qui peut être utilisée pour configurer votre environnement de compilation QMK, fonctionne avec QMK, et qui rend l'utilisation de plusieurs copies de `qmk_firmware` plus simple. Nous recommandons d'installer et de mettre à jour ceci régulièrement.
+
+## Installer en utilisant Homebrew (macOS, quelques Linux)
+
+Si vous avez installé [Homebrew](https://brew.sh) vous pouvez entrer ce qui suit et installer QMK:
+
+```
+brew tap qmk/qmk
+brew install qmk
+export QMK_HOME='~/qmk_firmware' # Optional, set the location for `qmk_firmware`
+qmk setup  # This will clone `qmk/qmk_firmware` and optionally set up your build environment
+```
+
+## Installer en utilisant easy_install ou pip
+
+Si votre système n'est pas listé ci-dessus, vous pouvez installer QMK manuellement. Premièrement, vérifiez que vous avez bien installé Python 3.5 (ou plus récent) et pip. Ensuite, installez QMK avec cette commande:
+
+```
+pip3 install qmk
+export QMK_HOME='~/qmk_firmware' # Optional, set the location for `qmk_firmware`
+qmk setup  # This will clone `qmk/qmk_firmware` and optionally set up your build environment
+```
+
+## Paquets pour d'autres systèmes d'exploitation
+
+Nous recherchons des gens pour créer et maintenir un paquet `qmk` pour plus de systèmes d'exploitation. Si vous voulez créer un paquet pour votre système d'exploitation, suivez ces directives:
+
+* Suivez les bonnes pratiques pour votre système d'exploitation lorsqu'elles entrent en conflit avec ces directives
+    * Documentez pourquoi dans un commentaire lorsque vous ne les suivez pas
+* Installez en utilisant un virtualenv
+* Expliquez à l'utilisateur de définir la variable d'environnement `QMK_Home` pour "check out" les sources du firmware à un autre endroit que `~/qmk_firmware`.
+
+# CLI locale
+
+Si vous ne voulez pas utiliser la CLI globale, il y a une CLI locale empaquetée avec `qmk_firmware`. Vous pouvez le trouver dans `qmk_firmware/bin/qmk`. Vous pouvez lancer la commande `qmk` depuis n'importe quel répertoire et elle fonctionnera toujours sur cette copie de `qmk_firmware`.
+
+**Exemple**:
+
+```
+$ ~/qmk_firmware/bin/qmk hello
+Ψ Hello, World!
+```
+
+## Limitations de la CLI locale
+
+Il y a quelques limitations à la CLI locale comparé à la globale:
+
+* La CLI locale ne supporte pas `qmk setup` ou `qmk clone`
+* La CLI locale n'opère pas sur le même arbre `qmk_firmware`, même si vous avez plusieurs dépôts clonés.
+* La CLI locale ne s'exécute pas dans un virtualenv, donc il y a des risques que des dépendances seront en conflit
+
+# Les commandes CLI
+
+## `qmk compile`
+
+Cette commande permet de compiler le firmware de n'importe quel répertoire. Vous pouvez compiler des exports JSON de <https://config.qmk.fm> ou compiler des keymaps du dépôt.
+
+**Utilisation pour les exports de configuration**:
+
+```
+qmk compile <configuratorExport.json>
+```
+
+**Utilisation pour les Keymaps**:
+
+```
+qmk compile -kb <keyboard_name> -km <keymap_name>
+```
+
+## `qmk cformat`
+
+Cette commande formatte le code C en utilisant clang-format. Lancez-la sans arguments pour formatter tout le code core, ou passez les noms de fichiers à la ligne de commande pour la lancer sur des fichiers spécifiques.
+
+**Utilisation**:
+
+```
+qmk cformat [file1] [file2] [...] [fileN]
+```
+
+## `qmk config`
+
+Cette commande vous permet de configurer le comportement de QMK. Pour la documentation complète de `qmk config`, regardez [Configuration de CLI](cli_configuration.md).
+
+**Utilisation**:
+
+```
+qmk config [-ro] [config_token1] [config_token2] [...] [config_tokenN]
+```
+
+## `qmk doctor`
+
+Cette commande examine votre environnement et vous alertes des potentiels problèmes de compilation ou de flash.
+
+**Utilisation**:
+
+```
+qmk doctor
+```
+
+## `qmk new-keymap`
+
+Cette commande crée une nouvelle keymap basée sur une keymap par défaut d'un clavier existant.
+
+**Utilisation**:
+
+```
+qmk new-keymap [-kb KEYBOARD] [-km KEYMAP]
+```
+
+## `qmk pyformat`
+
+Cette commande formatte le code python dans `qmk_firmware`.
+
+**Utilisation**:
+
+```
+qmk pyformat
+```
+
+## `qmk pytest`
+
+Cette commande démarre la suite de test python. Si vous faites des changements dans le code Python, assurez vous que les tests se lancent avec succès.
+
+**Utilisation**:
+
+```
+qmk pytest
+```

docs/fr-FR/cli_configuration.md

@@ -0,0 +1,121 @@
+# Configuration de QMK CLI
+
+Ce document explique comment fonctionne la commande `qmk config`.
+
+# Introduction
+
+La configuration pour QMK CLI est un système clé/valeur. Chaque clé est composée d'une sous-commande et d'un argument séparé par une virgule. Cela permet une traduction simple et directe entre les clés de configuration et l'argument qu'elle définit.
+
+## Exemple simple
+
+Comme exemple, regardons la commande `qmk compile --keyboard clueboard/66/rev4 --keymap default`.
+
+Il y a deux arguments de ligne de commande qui peuvent être lu de la configuration:
+
+* `compile.keyboard`
+* `compile.keymap`
+
+Essayons de les définir:
+
+```shell
+$ qmk config compile.keyboard=clueboard/66/rev4 compile.keymap=default
+compile.keyboard: None -> clueboard/66/rev4
+compile.keymap: None -> default
+Ψ Wrote configuration to '/Users/example/Library/Application Support/qmk/qmk.ini'
+```
+
+Maintenant, je peux lancer la commande `qmk compile` sans avoir à spécifier mon clavier et keymap à chaque fois.
+
+## Définir les options par défaut
+
+Parfois, il est utile de partager une configuration entre plusieurs commandes. Par exemple, plusieurs commandes prennent un argument `--keyboard`. Plutôt que de devoir définir cette valeur pour chaque commande, vous pouvez définir une valeur d'utilisateur qui sera utilisée par toutes les commandes qui prennent cet argument.
+
+Exemple:
+
+```
+$ qmk config user.keyboard=clueboard/66/rev4 user.keymap=default
+user.keyboard: None -> clueboard/66/rev4
+user.keymap: None -> default
+Ψ Wrote configuration to '/Users/example/Library/Application Support/qmk/qmk.ini'
+```
+
+# CLI Documentation (`qmk config`)
+
+La commande `qmk config` est utilisée pour intéragir avec la configuration sous-jacente. Lancée sans argument, elle affiche la configuration courante. Lorsque des arguments sont définis, ils sont considérés comme étant des jetons de configuration, qui sont des chaînes de caractère ne contenant aucun espace avec le format suivant:
+
+    <subcommand|general|default>[.<key>][=<value>]
+
+## Définir des valeurs de configuration
+
+Vous pouvez définir des valeurs de configuration en mettant le caractère égal (=) dans votre clé de configuration. La clé doit toujours être dans le format complet `<section>.<key>`.
+
+Exemple:
+
+```
+$ qmk config default.keymap=default
+default.keymap: None -> default
+Ψ Wrote configuration to '/Users/example/Library/Application Support/qmk/qmk.ini'
+```
+
+## Lire des valeurs de configuration
+
+Vous pouvez lire les valeurs de configuration pour la totalité de la configuration, une seule clé, ou une section entière. Vous pouvez aussi spécifier plusieurs clés pour afficher plus d'une valeur.
+
+### Exemple avec la totalité de la configuration
+
+    qmk config
+
+### Exemple avec une section entière
+
+    qmk config compile
+
+### Exemple avec une clé unique
+
+    qmk config compile.keyboard
+
+### Exemple avec plusieurs clés
+
+    qmk config user compile.keyboard compile.keymap
+
+## Supprimer des valeurs de configuration
+
+Vous pouvez supprimer une valeur de configuration en la définissant avec la chaîne spéciale `None`.
+
+Exemple:
+
+```
+$ qmk config default.keymap=None
+default.keymap: default -> None
+Ψ Wrote configuration to '/Users/example/Library/Application Support/qmk/qmk.ini'
+```
+
+## Plusieurs opérations
+
+Vous pouvez combiner plusieures opérations d'écriture et de lecture en une seule commande. Elle seront exécutées et affichées dans l'ordre:
+
+```
+$ qmk config compile default.keymap=default compile.keymap=None
+compile.keymap=skully
+compile.keyboard=clueboard/66_hotswap/gen1
+default.keymap: None -> default
+compile.keymap: skully -> None
+Ψ Wrote configuration to '/Users/example/Library/Application Support/qmk/qmk.ini'
+```
+
+# Options de configuration utilisateur
+
+| Clé | Valeur par défaut | Description |
+|-----|---------------|-------------|
+| user.keyboard | None | Le chemin d'accès vers le clavier (Exemple: `clueboard/66/rev4`) |
+| user.keymap | None | Le nom de la keymap (Exemple: `default`) |
+| user.name | None | Le nom d'utilisateur GitHub de l'utilisateur. |
+
+# Toutes les options de configuration
+
+| Clé | Valeur par défaut | Description |
+|-----|---------------|-------------|
+| compile.keyboard | None | Le chemin d'accès vers le clavier (Exemple: `clueboard/66/rev4`) |
+| compile.keymap | None | Le nom de la keymap (Exemple: `default`) |
+| hello.name | None | Le nom à saluer lorsque démarré. |
+| new_keyboard.keyboard | None | Le chemin d'accès vers le clavier (Exemple: `clueboard/66/rev4`) |
+| new_keyboard.keymap | None | Le nom de la keymap (Example: `default`) |

docs/fr-FR/contributing.md

@@ -0,0 +1,154 @@
+# Comment contribuer
+
+👍🎉 Premièrement, merci de prendre le temps de lire ceci et de contribuer! 🎉👍
+
+Les contributions de tiers nous aide à améliorer et faire grandir QMK. Nous voulons rendre les pull requests et le processus de contribution utile et simple à la fois pour les contributeurs et les mainteneurs. C'est pourquoi nous avons mis en places des directives pour les contibuteurs afin que votre pull request puisse être accepté sans changement majeur.
+
+* [Aperçu du projet](#project-overview)
+* [Conventions de codage](#coding-conventions)
+* [Directives générales](#general-guidelines)
+* [Que veut dire le code de conduite pour moi?](#what-does-the-code-of-conduct-mean-for-me)
+
+## Je ne veux pas lire tout ce pavé! J'ai juste une question!
+
+Si vous voulez poser une question sur QMK, vous pouvez le faire sur le [sous-reddit OLKB](https://reddit.com/r/olkb) ou sur [Discord](https://discord.gg/Uq7gcHh).
+
+Merci de garder ceci en tête:
+
+* Cela peut prendre plusieurs heures pour que quelqu'un réponde à votre question. Merci d'être patient!
+* Tous ceux impliqués avec QMK fait don de son temps et de son énergie. Nous ne sommes pas payés pour travailler sur ou répondre aux questions concernant QMK.
+* Essayez de poser vos questions de manière à ce qu'elles soient le plus simple à répondre possible. Si vous n'êtes pas sûrs de savoir comment faire, voici quelques bon guides (en anglais):
+  * https://opensource.com/life/16/10/how-ask-technical-questions
+  * http://www.catb.org/esr/faqs/smart-questions.html
+
+# Aperçu du projet
+
+QMK est majoritairement écrit en C, avec quelques fonctions et parties spécifiques écrites en C++. Il est destiné aux processeurs intégrés que l'on trouve dans des clavier, particulièrement AVR ([LUFA](http://www.fourwalledcubicle.com/LUFA.php)) et ARM ([ChibiOS](http://www.chibios.com)). Si vous maîtrisez déjà la programmation sur Arduino, vous trouverez beaucoup de concepts et de limitations familiers. Une expérience préalable avec les Arduino n'est pas nécessaire à contribuer avec succès à QMK.
+
+<!-- FIXME: We should include a list of resources for learning C here. -->
+
+# Où trouver de l'aide?
+
+Si vous avez besoin d'aide, vous pouvez [ouvrir une issue](https://github.com/qmk/qmk_firmware/issues) ou [un chat sur Discord](https://discord.gg/Uq7gcHh).
+
+# Comment contribuer?
+
+Vous n'avez encore jamais contribué à un projet open source? Vous vous demandez comment les contributions dans QMK fonctionnent? Voici un aperçu rapide!
+
+0. Enregistrez-vous sur [GitHub](https://github.com).
+1. Définissez une keymap à contribuer, [trouvez une issue](https://github.com/qmk/qmk_firmware/issues) que vous souhaitez corriger, ou [une fonction](https://github.com/qmk/qmk_firmware/issues?q=is%3Aopen+is%3Aissue+label%3Afeature) que vous voulez ajouter.
+2. Créez un fork sur le dépôt associé avec une issue sur votre compte GitHub. Cela veut dire que vous allez avoir une copie du dépôt sous `votre-login-GitHub/qmk_firmware`.
+3. Clonez le dépôt sur votre macine locale en utilisant `git clone https://github.com/login-github/repository-name.git`.
+4. Si vous travaillez sur une nouvelle fonctionnalité, pensez à ouvrir une issue pour parler avec nous du travail que vous souhaitez démarrer.
+5. Créez une nouvelle branche pour votre correctif en utilisant `git checkout -b nom-de-branche`.
+6. Faites les changements nécessaires pour corriger le problème ou ajouter la fonctionnalité.
+7. Utilisez `git add chemin-de-fichier` pour ajouter les contenus des fichiers modifiés au "snapshot" que git utilise pour gérer l'état du projet, appelé aussi l'index.
+8. Utilisez `git commit -m "Insérez une description courte des changements (en anglais)"` pour enregistrer le contenu de l'index avec un message descriptif.
+9. Poussez les changements vers votre dépôt sur GitHub en utilisant `git push origin nom-de-branche`.
+10. Créez un pull request sur [QMK Firmware](https://github.com/qmk/qmk_firmware/pull/new/master).
+11. Donnez un titre à votre pull request en utilisant une description courte des changements que vous avez fait et ajoutez le numéro de l'issue ou du bug associé avec votre changement. Les commentaires de PR devraient se faire en anglais de préférence. Par exemple, vous pouvez utiliser un titre tel que celui-là: "Added more log outputting to resolve #4352".
+12. Dans la description du pull request, expliquez les changements que vous avez fait et tous les problèmes qui existent, selon vous, sur le pull request que vous avez fait. Vous pouvez aussi utiliser la description pour poser des questions au mainteneur. Il n'est pas nécessaire que votre pull request soit parfait (aucun pull request ne l'est), le reviewer sera là pour vous aider à résoudre les problèmes et l'améliorer!
+13. Attendez que le pull request soit revu par un mainteneur.
+14. Faites des changements au pull request si le mainteneur le recommande.
+15. Célébrez votre succès une fois votre pull request fusionné!
+
+# Conventions de codage
+
+La grande majorité de notre style est plutôt simple à comprendre. Si vous connaissez C ou Python, vous ne devriez pas avoir trop de difficulté avec notre style.
+
+* [Conventions de codage - C](coding_conventions_c.md)
+* [Conventions de codage - Python](coding_conventions_python.md)
+
+# Directives générales
+
+Nous avons un certain nombre de type de changements dans QMK, chacun nécessitant un niveau de rigueur différent. Nous voulons que vous gardiez les directives suivantes en tête quel que soit le changement que vous êtes en train de faire.
+
+* Séparez les PR dans des unités logiques. Par exemple, ne soumettez pas un PR qui couvre deux fonctionnalités séparées, soumettez plutôt un PR pour chaque fonctionnalité.
+* Vérifiez les espaces blancs non nécessaires avec `git diff --check` avant de commit.
+* Assurez-vous que votre code compile.
+  * Keymaps: Assurez-vous que `make keyboard:your_new_keymap` ne renvoie pas d'erreur.
+  * Claviers: Assurez-vous que `make keyboard:all` ne renvoie pas d'erreur.
+  * Core: Assurez-vous que `make all` ne renvoie pas d'erreur.
+* Assurez-vous que les messages de commit soient compréhensibles d'eux-même. Vous devriez écrire une description simple (pas plus de 70 caractères) sur la première ligne, suivi d'une ligne vide, suivi d'un détail de votre commit, si nécessaire. Exemple:
+
+```
+Adjust the fronzlebop for the kerpleplork
+
+The kerpleplork was intermittently failing with error code 23. The root cause was the fronzlebop setting, which causes the kerpleplork to activate every N iterations.
+
+Limited experimentation on the devices I have available shows that 7 is high enough to avoid confusing the kerpleplork, but I'd like to get some feedback from people with ARM devices to be sure.
+```
+
+## Documentation
+
+La documentation est l'une des manière les plus simples de démarrer la contribution sur QMK. Il est simple de trouver des endroits où la documentation est fausse ou incomplète, et il est tout aussi simple de la corriger! Nous avons aussi grandement besoin de quelqu'un pour éditer notre documentation, donc si vous avez des compétences en édition mais que vous n'êtes pas sûr de savoir où aller, n'hésitez pas [demandez de l'aide](#where-can-i-go-for-help)!
+
+Vous trouverez toute notre documentation dans le répertoire `qmk_firmware/docs`, ou si vous préférez utiliser des outils web, vous pouvez cliquer sur le bouton "Suggest An Edit" en haut de chaque page sur http://docs.qmk.fm/.
+
+Lorsque vous donnez des exemples de code dans la documentation, essayez de suivre les conventions de nommage utilisées ailleurs dnas la documentation. Par exemple, standardisez les enums en utilisant `my_layers` ou `my_keycodes` afin de garder une consistance:
+
+```c
+enum my_layers {
+  _FIRST_LAYER,
+  _SECOND_LAYER
+};
+
+enum my_keycodes {
+  FIRST_LAYER = SAFE_RANGE,
+  SECOND_LAYER
+};
+```
+
+## Keymaps
+
+La plupart des contributeurs débutants démarrent avec leurs keymaps personnelles. Nous essayons de garder les standards pour les keymaps pluôt simple (les keymaps reflètent, après tout, la personnalité de leurs créateurs) mais nous demandons que vous suiviez les directives suivantes afin que d'autres puissent découvrir et apprendre de votre keymap.
+
+* Ecrivez un fichier `readme.md` en utilisant [la template](documentation_templates.md).
+* Tous les PR de keymaps doivent être "squashés", donc si la manière dont vos commits sont squashés vous est important, vous devez le faire vous-même.
+* Ne regroupez pas des fonctionnalités avec votre PR de keymap. Envoyez d'abord votre fonctionnalité, puis créez un second PR pour la keymap.
+* N'incluez pas de fichier `Makefile` dans votre dossier de keymap (ils ne sont plus utilisés)
+* Mettez à jour les copyrights dans les en-têtes de fichiers (cherchez `%YOUR_NAME%`)
+
+## Claviers
+
+Les claviers sont la raison d'être de QMK. Certains claviers sont maintenus par la communauté, alors que d'autre sont maintenus par les gens responsables de la création du clavier. Le fichier `readme.md` devrait vous informer de qui maintient le clavier. Si vous avez des questions concernant un clavier en particulier, vous pouvez [Ouvrir une issue](https://github.com/qmk/qmk_firmware/issues) et tagger le mainteneur dans votre question.
+
+Nous vous demandons aussi que vous suiviez ces directives:
+
+* Ecrivez un fichier `readme.md` en utilisant [le template](documentation_templates.md).
+* Gardez un nombre de commits raisonnable, ou nous squasherons votre PR.
+* Ne regroupez pas des fonctionnalités avec le PR pour votre clavier. Envoyez d'abord votre fonctionnalité, puis créez un second PR pour le clavier.
+* Appelez les fichiers `.c`/`.h` du nom du dossier parent, par exemple `/keyboards/<kb1>/<kb2>/<kb2>.[ch]`
+* N'incluez pas de fichier `Makefile` dans votre dossier de keymap (ils ne sont plus utilisés)
+* Mettez à jour les copyrights dans les en-têtes de fichiers (cherchez `%YOUR_NAME%`)
+
+## Quantum/TMK Core
+
+Faites attention d'être sûr d'implémenter votre nouvelle fonctionnalité de la meilleure manière qu'il soit avant d'investir beaucoup de travail à son développement. Vous pouvez apprendre les bases de QMK en lisant [Comprendre QMK](understanding_qmk.md), qui vous donnera une idée du flux du programme QMK. A partir de là, parlez nous afin de définir la meilleure façon d'implémenter votre idée. Il y a deux façons principale de le faire:
+
+* [Chat sur Discord](https://discord.gg/Uq7gcHh)
+* [Ouvrir une Issue](https://github.com/qmk/qmk_firmware/issues/new)
+
+Les PR de nouvelles fonctionnalités de de correction de bug affectent tous les claviers. Nous sommes aussi dans un processus de restructuration de QMK. Pour cette raison, il est absolument nécessaire que tout changement important ou significatif soit discuté avant que l'implémentation soit faite. Si vous ouvrez un PR sans nous avoir parlé, préparez vous à faire des refontes significatives si vous changements ne sont pas compatibles avec ce que nous avons planifié.
+
+Voici quelques choses à garder en tête lorsque vous travaillez sur une fonctionnalité ou un bug fix.
+
+* **Désactivé par défaut** - la mémoire est plutôt limitée sur la plupart des puces que QMK supporte, et il est important que les keymaps courantes ne soient pas cassées. S'il vous plaît faites que vos features doivent être **activées** plutôt que désactivées. Si vous pensez qu'elle devrait être activée par défaut, ou que cela réduit la taille du code, parlez-nous en.
+* **Compilez localement avant de soumettre** - Cela devrait aller sans dire, mais votre code doit compiler! Notre système Travis devrait relever les problèmes, mais il est généralement plus rapide de compiler quelques claviers en local plutôt que d'attendre le retour des résultats
+* **Faites attention aux révisions et différentes bases de puces** - beaucoup de claviers ont des révisions qui permettent des changements de configuration mineurs, voir des bases de chip différentes. Essayez de faire que votre fonctionnalité soit supportée à la fois sur ARM et AVR, ou désactivez-là automatiquement sur les plateformes non supportées.
+* **Expliquez votre fonctionnalité** - Documentez-là dans `docs/`, soit dans un nouveau fichier, ou dans une partie d'un fichier existant. Si vous ne la documentez pas, personne ne pourra bénéficier de votre dur labeur.
+
+Nous vous demandons aussi de suivre ces ces directives:
+
+* Gardez un nombre de commits raisonnable, ou nous squasherons votre PR.
+* Ne regroupez pas des claviers ou des keymaps avec des changements core. Soumettez vos changements core en premier.
+* Ecrivez des [Tests Unitaires](unit_testing.md) pour votre fonctionnalité.
+* Suivez le style du fichier que vous modifiez. Si le style n'est pas clair ou qu'il y a un mélange de fichiers, vous devriez vous conformer aux [conventions de codage](#coding-conventions) au dessus.
+
+## Refactoriser
+
+Afin de maintenir une vision claire sur comment les choses sont architectuées dans QMK, nous essayons de planifier des refactorisations en profondeur et qu'un collaborateur fasse le changement. Si vous avez une idée de refactorisation, ou une suggestion, [ouvrez une issue] [open an issue](https://github.com/qmk/qmk_firmware/issues), nous adorons discuter de comment améliorer QMK.
+
+# Que veut dire le code de conduite pour moi?
+
+Note [Code De Conduite](https://github.com/qmk/qmk_firmware/blob/master/CODE_OF_CONDUCT.md) veut dire que vous avez la responsabilité de traiter tout le monde dans le projet avec respect et courtoisie, peut importe leur identité. Si vous êtes victime d'une attitude ou de commentaires inapropriés, tels que décrit dans notre Code de Conduite, nous sommes là pour vous et nous ferons de notre mieux pour nous assurer que le fautif soit réprimandé, tel que décrit dans notre code.

docs/fr-FR/flashing.md

@@ -0,0 +1,236 @@
+# Instructions pour flasher et informations sur les bootloader
+
+Les claviers utilisent différents types de bootloaders et certains doivent être flashés différement. Heureusement, certains projets comme la [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) ont pour objectifs de permettre de flasher les différents bootloader sans trop se faire de soucis et ça peut importe les manières de les flasher.
+
+Si vous avez un bootloader sélectionné avec la variable `BOOTLOADER` dans votre fichier `rules.mk` alors QMK vas automatiquement calculer si votre fichier .hex n'est pas trop grand pour être flashé sur votre appareil, et il affichera la taille finale du firmware. Pour vérifier la taille manuellement, vous pouvez aussi compiler le firmware avec l'option `check-size`. Exemple : `make planck/rev4:default:check-size`.
+
+## DFU
+
+Le bootloader pour les processeurs Atmel DFU est fourni par défaut sur tous les processeurs atmega32u4. Celui-ci est utilisé par beaucoup de claviers plus vieux que les OLKB et Clueboard qui ont leur propre ICs sur leurs PCBs. D'autres claviers utilisent le bootloader DFU de LUFA (ou son fork QMK), notamment les nouveaux claviers OLKB. Ce dernier ajoute des fonctionnalités spécifiques sur le matériel.
+
+Pour vérifier la compatibilité avec le bootloader DFU, vérifiez que ce bloc de code est présent dans votre fichier `rules.mk`. Parfois il peut être inscrit `lufa-dfu` ou `qmk-dfu` à la place.
+
+```make
+# Bootloader selection
+#   Teensy       halfkay
+#   Pro Micro    caterina
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
+BOOTLOADER = atmel-dfu
+```
+
+Méthodes de flash compatibles :
+
+* [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (interface graphique recommandé)
+* [dfu-programmer](https://github.com/dfu-programmer/dfu-programmer) / `:dfu` avec QMK (outil en ligne de commande recommandé)
+* [Atmel's Flip](http://www.microchip.com/developmenttools/productdetails.aspx?partno=flip) (non recommandé)
+
+Ordre des actions :
+
+1. Pressez le keycode `RESET`, ou appuyez sur le bouton physique RESET ou alors créez un contact entre RST et GND.
+2. Attendez que l'OS detecte l'appareil.
+3. Éffacez la mémoire, cela peut être fait automatiquement.
+4. Flasher le fichier .hex.
+5. Redémarrez l'appareil en mode « application », cela peut être fait automatiquement.
+
+Alternativement :
+
+    make <keyboard>:<keymap>:dfu
+
+### DFU QMK
+
+QMK a un fork du bootloader LUFA DFU qui vous permet de faire un simple scan de la matrice pour quitter le bootloader et retourner à l'application. En même temps que le flash se produira, il est possible de faire flasher un led ou de produire un son via un haut parleur. Pour activer ces fonctionnalités, vous pouvez utiliser ce bloc dans votre fichier `config.h` (La touche permettant de quitter le bootloader a besoin d'être reliée entre les ports définis en INPUT et OUTPUT ici):
+
+    #define QMK_ESC_OUTPUT F1 // usually COL
+    #define QMK_ESC_INPUT D5 // usually ROW
+    #define QMK_LED E6
+    #define QMK_SPEAKER C6
+
+Le fabriquant et le nom du produit proviennent de vos définitions dans fichier  `config.h`, et la chaîne de caractère « bootloader » est ajoutée au nom du prodruit.
+
+Pour génerer le bootloader, utilisez la cible `bootloader`. Exemple : `make planck/rev4:default:bootloader`.
+
+Pour génerer un fichier .hex prêt pour la production qui contiendra tant l'application que le bootloader, utilisez la cible `production`. Exemple : `make planck/rev4:default:production`.
+
+### Commandes DFU
+
+Il y a plusieurs commandes DFU que vous pouvez utiliser pour flasher le firmware sur un appareil DFU.
+
+* `:dfu` - C'est l'option normale qui attend qu'un appareil DFU soit disponible et qui flashe le firmware dès que c'est le cas. La vérification sera faite toutes les 5 secondes.
+* `:dfu-ee` - Cette option flash un fichier `.eep` à la place d'un fichier `.hex`. Ce cas est plutôt rare.
+* `:dfu-split-left` - Cette option flashe le firmware normal comme avec l'option (`:dfu`). Mais cela aussi flash le coté gauche du fichier EEPROM pour les claviers scindés. _C'est l'option idéale pour un clavier scindé basé sur le Elite C_
+* `:dfu-split-right` - Cette option flashe le firmware normal comme avec l'option (`:dfu`).  Mais cela aussi flash le coté droite du fichier EEPROM pour les claviers scindés. _C'est l'option idéale pour un clavier scindé basé sur le Elite C_
+
+## Caterina
+
+Les cartes arduinos et leurs clones utilisent le [bootloader Caterina](https://github.com/arduino/ArduinoCore-avr/tree/master/bootloaders/caterina) (tous les claviers utilisant un Pro Micro, ou un clone). Ils utilisent aussi le protocole avr109 pour communiquer en virtuellement en série (serial en Anglais). Les bootloaders comme le [A-Star](https://www.pololu.com/docs/0J61/9) sont basés sur Caterina.
+
+Pour vérifier la compatibilité avec un bootloader Caterina, vérifiez que ce bloc est présent dans votre fichier `rules.mk` :
+
+```make
+# Bootloader selection
+#   Teensy       halfkay
+#   Pro Micro    caterina
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
+BOOTLOADER = caterina
+```
+
+Flashers compatibles :
+
+* [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (Interface graphique recomandée)
+* [avrdude](http://www.nongnu.org/avrdude/) avec avr109 / `:avrdude` (Outil en ligne de commande recomandé)
+* [AVRDUDESS](https://github.com/zkemble/AVRDUDESS)
+
+Séquence de flash : 
+
+1. Pressez la touche avec le keycode `RESET`, ou reliez les ports GND et RST. Vous n'avez que 7 secondes pour flasher une fois que l'opération a été faite.
+2. Attendez que l'OS détecte l'appareil.
+3. Flasher le fichier .hex.
+4. Attendez que l'appareil redémarre automatiquement.
+
+ou, utilisez :
+
+    make <keyboard>:<keymap>:avrdude
+
+ou, si vous vous voulez flasher plusieurs claviers, utilisez la commande suivante :
+
+    make <keyboard>:<keymap>:avrdude-loop
+
+Quand vous avez fini de flasher vos claviers, vous aurez besoin d'utiliser Ctrl + C ou alors la touche ayant la fonction similaire sur votre OS pour sortir de la boucle.
+
+## Halfkay
+
+Halfkay est un protocole ultra-simple développé par PJRC qui utilise HID et qui est fourni avec tous les Teensys après le modèle 2.0.
+
+Pour vérifier la compatibilité avec le booloader Halfkay, vérifiez que ce bloc est présent dans votre fichier `rules.mk` :
+
+```make
+# Bootloader selection
+#   Teensy       halfkay
+#   Pro Micro    caterina
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
+BOOTLOADER = halfkay
+```
+
+Flasher compatibles :
+
+* [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (Interface graphique recomandée)
+* [Teensy Loader](https://www.pjrc.com/teensy/loader.html) (petit utilitaire ultra simple)
+ [Teensy Loader en ligne de commande](https://www.pjrc.com/teensy/loader_cli.html) (Outil en ligne de commande recommandé)
+
+Séquence de flash :
+
+1. Pressez la touche du keycode `RESET`, ou reliez les ports RST et GND rapidement. Vous avez ensuite 7 secondes pour réaliser le flash.
+2. Attendez que l'OS détecte l'appareil.
+3. Flasher le fichier .hex.
+4. Redémarrez l'appareil en mode « application ». Cela peut être fait automatiquement.
+
+## USBasploader
+
+USBasploader est un bootloader développé par matrixstorm. Il est utilisé sur des processeurs AVR non-USB comme le ATmega328P, qui fonctionne grâce à V-USB.
+
+Pour vérifier la compatibilité avec le booloader USBasploader, vérifiez que ce bloc est présent dans votre fichier `rules.mk` :
+
+```make
+# Bootloader selection
+#   Teensy       halfkay
+#   Pro Micro    caterina
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
+BOOTLOADER = USBasp
+```
+
+Flashers compatibles :
+
+* [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (Interface graphique recommandé)
+* [avrdude](http://www.nongnu.org/avrdude/) avec le programmeur `usbasp`.
+* [AVRDUDESS](https://github.com/zkemble/AVRDUDESS)
+
+Séquence de flash :
+
+1. Pressez la touche du keycode `RESET`, ou reliez le port de boot pendant que RST et GND snt reliés. Cela doit être fait très rapidement.
+2. Attendez que l'OS détecte l'appareil.
+3. Flasher le fichier .hex.
+4. Redémarrez l'appareil en mode « application ». Cela peut être fait automatiquement.
+
+## BootloadHID
+
+BootloadHID est un bootloader pour les microcontroleurs AVR. L'utilitaire de téleversement ne demande pas de drivers au niveau du kernel et peut être lancé sans installer aucune DLLs.
+
+Pour vérifier la compatibilité avec le bootloader bootloadHID, vérifiez que ce bloc existe dans votre fichier `rules.mk` : 
+
+```make
+# Bootloader selection
+#   Teensy       halfkay
+#   Pro Micro    caterina
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
+BOOTLOADER = bootloadHID
+```
+
+Utilitaires de flash compatibles :
+
+* [HIDBootFlash](http://vusb.wikidot.com/project:hidbootflash) (Utilitaire avec interface graphique recommandé)
+* [bootloadhid Command Line](https://www.obdev.at/products/vusb/bootloadhid.html) / `:BootloadHID` avec QMK (utilitaire en ligne de commande recommandé)
+
+Séquence de flash
+
+1. Entrez dans le bootloader en utilisant l'une de ces méthodes :
+    * Pressez la touche du keycode `RESET` (Cela ne fonctionnera pas sur certains appareils).
+    * Verouillez la touche « Salt » tout en branchant le clavier (Géneralement ce principe est documenté dans le fichier readme du clavier)
+2. Attendez que l'OS détecte l'appareil.
+3. Flasher le fichier .hex.
+4. Redémarrez l'appareil en mode « application ». Cela peut être fait automatiquement.
+
+Ou alors :
+
+    make <keyboard>:<keymap>:bootloadHID
+
+## STM32
+
+Tous les processeurs STM32 contiennent un bootloader installé en usine qui ne peut pas être modifié ou supprimé. Certains processeurs STM32 ont des bootloaders qui ne peuvent pas être programmés par USB (ex : STM32F103) mais le processus reste le même.
+
+Pour le moment, aucune variable `BOOTLOADER` n'est nécessaire dans le fichier `rules.mk`.
+
+Flashers compatibles :
+
+* [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (interface graphique recommandé)
+* [dfu-util](https://github.com/Stefan-Schmidt/dfu-util) / `:dfu-util` (utilitaire en ligne de commande recommandé)
+
+Séquence pour flasher:
+
+1. Entrez dans le bootloader en utilisant l'une de ces méthodes :
+    * Utilisez une touche sur laquelle le keycode `RESET` (Cela peut ne pas fonctionner sur les appareils STM32F042)
+    * Si un circuit de réinitialisation (Reset) est présent alors utilisé le bouton qui lui est dédié.
+    * Autrement, vous devez réaliser une liaison entre BOOT0 et VCC (en appuyant sur le bouton ou à l'aide d'un pont) puis faire un pont entre RESET et GND et enfin relacher le pont BOOT0.
+2. Attendre que l'os détecte l'appareil.
+3. Flasher un fichier `.bin`.h
+    * Vous allez recevoir un avertissement à propos de la signature DFU. Ignorez-la.
+4. Réinitialisez l'appareil en mode « application ». Cela peut être fait automatiquement.
+    * Si vous êtes en train de travailler en ligne de commande, par exemple avec un `make planck/rev6:default:dfu-util` alors soyez bien sur que l'argument `:leave` est passé aux argument DFU grâce à la variable `DFU_ARGS` à l'intérieur de votre fichier `rules.mk` (Ex : `DFU_ARGS = -d 0483:df11 -a 0 -s 0x08000000:leave`) afin que votre appareil redémarre après avoir été flashé.
+
+### Commandes STM32
+
+Il y a différentes commandes que vous pouvez utiliser pour flasher un firmware dans un appareil STM32  :
+
+* `:dfu-util` - La commande par défaut pour flasher un appareil STM32.
+* `:dfu-util-split-left` - Permet de flasher un firmware normalement, tout comme l'option précedente mais permet de configurer le coté gauche des paramètres EEPROM sur un clavier scindé.
+* `:dfu-util-split-right` - Permet de flasher un firmware normalement, tout comme l'option précedente mais permet de configurer le coté droit des paramètres EEPROM sur un clavier scindé.
+* `:st-link-cli` - Cela permet de flasher le firmware avec l'utilitaire en ligne de commande ST-LINK's plutôt que d'utiliser dfu-util.

docs/fr-FR/getting_started_getting_help.md

@@ -0,0 +1,15 @@
+# Trouver de l'aide
+
+Il y a beaucoup de ressources pour trouver de l'aide avec QMK.
+
+## Chat temps-réel
+
+Vous trouverez des développeurs QMK et des utilisateurs sur notre [Serveur Discord](https://discord.gg/Uq7gcHh) principal. Il y a des canaux spécifiques dans le serveurs pour discuter des firmware, toolbox, hardware et configurateurs.
+
+## Sous-Reddit OLKB
+
+Le forum officiel de QMK est [/r/olkb](https://reddit.com/r/olkb) sur [reddit.com](https://reddit.com).
+
+## Tickets GitHub
+
+Vous pouvez ouvrir un [ticket sur GitHub](https://github.com/qmk/qmk_firmware/issues). Ceci est spécialement pratique lorsque votre problème demande une discussion long terme ou un débugage.

docs/fr-FR/getting_started_github.md

@@ -0,0 +1,61 @@
+# Comment utiliser GitHub avec QMK
+
+GitHub peut être un peu compliqué pour ceux qui n'y sont pas familier. Ce guide va vous expliquer chaque étape de "fork", clone et envoi d'un pull request avec QMK.
+
+?> Ce guide part du principe que vous êtes suffisamment à l'aise pour envoyer commandes sur la ligne de commande et que vous avez Git installé sur votre système.
+
+Commencez par la [page GitHub de QMK](https://github.com/qmk/qmk_firmware), et vous verrez un bouton dans le coin en haut à droite qui indique "Fork":
+
+![Fork on Github](http://i.imgur.com/8Toomz4.jpg)
+
+Si vous faites partie d'une organisation, vous aurez besoin de savoir quel compte utiliser pour le fork. Dans la plupart des cas, vous voudrez créer le fork dans votre compte personnel. Une fois le fork complet (cela peut quelque fois prendre un peu de temps), appuyez sur le bouton "Clone or download":
+
+![Download from Github](http://i.imgur.com/N1NYcSz.jpg)
+
+Faites attention à sélectionner "HTTPS", et sélectionnez le liens et copiez-le:
+
+![HTTPS link](http://i.imgur.com/eGO0ohO.jpg)
+
+Ensuite, entrez `git clone` dans la ligne de commande, et collez votre lien:
+
+```
+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.
+```
+
+Vous avez maintenant votre fork QMK sur votre machine locale, vous pouvez ajouter votre keymap, la compiler et la flasher sur votre board. Une fois heureux avec vos changements, vous pouvez les ajouter, commit, et pousser vers votre fork comme suit:
+
+```
+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
+```
+
+Vos changements existent maintenant dans votre fork sur GitHub. Si vous allez à cete adresse (`https://github.com/<whoeveryouare>/qmk_firmware`), vous pouvez créer un nouveau "Pull Request" en cliquant sur ce bouton:
+
+![New Pull Request](http://i.imgur.com/DxMHpJ8.jpg)
+
+Maintenant, vous pourrez voir exactement ce que vous avez commité. Si ça vous semble bien, vous pouvez le finaliser en cliquant sur "Create Pull Request":
+
+![Create Pull Request](http://i.imgur.com/Ojydlaj.jpg)
+
+Une fois transmis, nous pourrons vous parler de vos changements, vous demander de faire des changements, et éventuellement de les accepter!
+
+Merci de contribuer à QMK :)

docs/fr-FR/getting_started_introduction.md

@@ -0,0 +1,62 @@
+# Introduction
+
+Le but de cette page est d'expliquer les informations de base qui vous serons nécessaire pour travailler sur le projet QMK. Il a pour pré-requis que vous soyez familier à la navigation à l'aide d'un shell Unix, mais ne s'attend pas à ce que vous soyez familier avec C ou la compilation en utilisant make.
+
+## Structure de base de QMK
+
+QMK est un fork du projet [tmk_keyboard](https://github.com/tmk/tmk_keyboard) créé par [Jun Wako](https://github.com/tmk). Le code originel de TMK, avec quelques modifications, se trouve dans le dossier `tmk`. Les additions que QMK amène au projet se trouvent dans le dossier `quantum`. Les projets de clavier se trouvent dans les dossiers `handwired` et `keyboard`.
+
+### Structure du Userspace
+
+Dans le dossier `users` se trouve un répertoire pour chaque utilisateur. C'est un endroit où les utilisateurs peuvent mettre du code qui serait partagé entre plusieurs claviers. Merci de lire la documentation  [Fonctionnalité Userspace](feature_userspace.md) pour plus d'information.
+
+### Structure du projet clavier
+
+Dans le dossier `keyboards`, son sous-dossier `handwired` et ses sous-dossiers pour les revendeurs et fabriquants (par exemple `clueboard`) se trouve un répertoire pour chaque projet clavier. Par exemple `qmk_firmware/keyboards/clueboard/2x1800`.
+
+A l'intérieur, vous trouverez la structure suivante:
+
+* `keymaps/`: différentes keymaps qui peuvent être compilées
+* `rules.mk`: Ce fichier définit les options "make" par défaut. Ne modifiez pas ce fichier directement, utilisez à la place un `rules.mk` spécifique à la keymap.
+* `config.h`: Ce fichier définit les options de compilation par défaut. Ne modifiez pas ce fichier directement, utilisez à la place un `config.h` spécifique à la keymap.
+* `info.json`: Le fichier utilisé pour définir les options de layout de QMK Configurator. Voyez [Support Configurator](reference_configurator_support.md) pour plus d'information.
+* `readme.md`: une brève description du clavier.
+* `<keyboardName>.h`: Ce fichier définit le layout du fichier par rapport à la matrice de commutation.
+* `<keyboardName>.c`: Ce fichier définit du code custom pour le clavier.
+
+Pour plus d'information sur la structure du projet, voyez [Directives clavier QMK](hardware_keyboard_guidelines.md).
+
+### Structure d'une Keymap
+
+Dans chaque dossier keymap, vous allez trouver les fichiers suivants. Seul le fichier `keymap.c` est nécessaire, et si le reste des fichiers n'existent pas, les options par défaut seront choisies.
+
+* `config.h`: les options de configuration de votre keymap
+* `keymap.c`: tout le code de votre keymap, requis
+* `rules.mk`: les features de QMK qui sont activées
+* `readme.md`: une description de votre keymap, comment d'autres l'utiliseront, et des explications des fonctionnalités. Uploadez les images vers un service comme imgur.
+
+# Le fichier `config.h`
+
+Le fichier `config.h` peut être mis à 3 endroits:
+
+* keyboard (`/keyboards/<keyboard>/config.h`)
+* userspace (`/users/<user>/config.h`)
+* keymap (`/keyboards/<keyboard>/keymaps/<keymap>/config.h`)
+
+Le système de compilation cherche automatiquement les fichiers de configuration dans l'ordre au dessus. Si vous souhaitez surcharger une configuration définie par un `config.h` précédent, vous devrez d'abord ajouter le code suivant.
+
+```
+#pragma once
+```
+
+Ensuite, pour surcharger l'option du fichier `config.h` précédent, vous devez `#undef` puis `#define` l'option à nouveau.
+
+Voici à quoi l'ensemble du code resemble une fois regroupé:
+
+```
+#pragma once
+
+// overrides go here!
+#undef MY_SETTING
+#define MY_SETTING 4
+```

docs/fr-FR/newbs.md

@@ -0,0 +1,23 @@
+# Le Guide pour débutant complet à QMK
+
+QMK est un firmware Open Source pour votre clavier mécanique. Vous pouvez utiliser QMK pour customiser votre clavier de manière simple et puissante. Tout le monde, du débutant complet au développeur avancé, ont utilisé avec succès QMK pour customiser leur clavier. Ce guide vous aidera à faire de même, quelles que soient vos compétences.
+
+Vous voulez savoir si votre clavier peut utiliser QMK? Si c'est un clavier mécanique que vous avez vous-même construit, il y a de bonnes chances que vous pouvez. Nous supportons un [grand nombre de "hobbyist boards"](http://qmk.fr/keyboards), donc même si votre clavier ne peut pas utiliser QMK, vous ne devriez pas avoir trop de problème pour en trouver un qui vous convienne.
+
+## Vue d'ensemble
+
+Il y a 7 sections principales dans ce guide:
+
+* [Pour débuter](fr-FR/newbs_getting_started.md)
+* [Compiler votre premier firmware en utilisant la ligne de commande](fr-FR/newbs_building_firmware.md)
+* [Compiler votre premier firmware en utilisant l'interface graphique en ligne](fr-FR/newbs_building_firmware_configurator.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)
+
+Ce guide a pour but principal d'aider quelqu'un qui n'a jamais compilé de logiciel avant. Les recommandations et les choix qu'il contient vont donc dans ce sens. Il y a des méthodes alternatives pour beaucoup de ces procédures, et nous supportons la plupart de ces alternatives. Si vous avez un doute sur comment accomplir une tâche, vous pouvez [nous demander de l'aide](fr-FR/getting_started_getting_help.md).
+
+## Ressources additionnelles
+
+* [Thomas Baart's QMK Basics Blog](https://thomasbaart.nl/category/mechanical-keyboards/firmware/qmk/qmk-basics/) – Un blog créé par un utilisateur qui couvre les bases de l'utilisation du Firmware QMK, vue d'un point de vue d'un nouvel utilisateur (anglais).

docs/fr-FR/newbs_best_practices.md

@@ -0,0 +1,161 @@
+# Bonnes Pratiques
+
+## Ou, "Comment j'ai appris à ne plus m'en faire et aimer Git."
+
+Ce document a pour but d'apprendre aux novices les meilleures solutions pour faciliter la contribution à QMK. Nous allons étudier le processus de contribution à QMK, détaillant quelques moyens de rendre cette tâche plus simple. Nous allons faire quelques erreurs afin de vous apprendre à les résoudre.
+
+Ce document suppose les choses suivantes:
+
+1. Vous avez un compte GitHub, et avez [créé un "fork" pour le dépôt qmk_firmware](fr-FR/getting_started_github.md) avec votre compte.
+2. Vous avez [configuré votre environnement de compilation](fr-FR/newbs_getting_started.md?id=environment-setup).
+
+## La branche master de votre fork: Mettre à jour souvent, ne jamais commit
+
+Il est hautement recommandé pour le développement de QMK, peu importe ce qui est fait ou où, de garder votre branche `master` à jour, mais de ne ***jamais*** commit dessus. A la place, faites tous vos changement dans une branche de développement et crééz des "pull requests" de votre branche lorsque vous développez.
+
+Pour réduire les chances de conflits de fusion (merge) — des cas où deux ou plus d'utilisateurs ont édité la même section d'un fichier en parallèle — gardez votre branche `master` relativement à jour et démarrez chaque nouveau développement en créant une nouvelle branche.
+
+### Mettre à jour votre branche master
+
+Pour garder votre branche `master` à jour, il est recommandé d'ajouter le dépôt du firmware QMK comme un dépôt distant (remote) dans git. pour se faire, ouvrez votre interface de ligne de commande Git et entrez:
+
+```bash
+git remote add upstream https://github.com/qmk/qmk_firmware.git
+```
+
+Pour vérifier que le dépôt a bien été ajouté, lancez la commande `git remote -v`, qui devrait retourner le résultat suivant:
+
+```bash
+$ 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)
+```
+
+Maintenant que c'est fait, vous pouvez vérifier les mises à jour au dépôt en lançant `git fetch upstream`. Cela récupère les branches et les tags &mdash; appelé de manière générale "refs" &mdash; du dépôt QMK, qui a maintenant le surnom `upstream`. Nous pouvons maintenant comparer les données sur notre "fork" `origin` à celles contenues par QMK.
+
+Pour mettre à jour la branche master de votre "fork", lancez les commandes suivantes (en appuyant sur Enter après chaque ligne):
+
+```bash
+git checkout master
+git fetch upstream
+git pull upstream master
+git push origin master
+```
+
+Cela vous change la branche courante en master, synchronise les données de réferences du dépôt QMK vers votre ordinateur. La commande pull tire les données de réferences vers votre branche courante puis les y téleverse. La commande push permet de pousser la branche courante (master) vers votre fork github.
+
+### Faire des changements
+
+Pour faire des changements, créez une nouvelle branche en entrant:
+
+```bash
+git checkout -b dev_branch
+git push --set-upstream origin dev_branch
+```
+
+Ceci crée une branche nommée `dev_branch`, bascule vers cette branche, et ensuite sauvegarde cette nouvelle branche vers votre fork. L'argument `--set-upstream` demande à git d'utiliser votre fork et la branche `dev_branch` à chaque fois que vous utilisez `git push` ou `git pull` depuis cette branche. Vous ne devez l'utiliser que pour le premier "push", après celà, vous pouvez utiliser simplement `git push` ou `git pull`, sans le reste des arguments.
+
+!> Avec `git push`, vous pouvez utiliser `-u` à la place de `--set-upstream` &mdash; `-u` est un alias pour `--set-upstream`.
+
+Vous pouvez appeler votre branche à peu prêt comme vous voulez, toutefois il est recommandé d'utiliser un nom qui est lié aux changements que vous allez faire.
+
+Par défaut, `git checkout -b` va faire de la branche actuelle la branche de base de votre nouvelle branche. Vous pouvez définir la base de votre nouvelle branche comme étant n'importe quelle branche existante qui n'est pas la courante en utilisant la commande:
+
+```bash
+git checkout -b dev_branch master
+```
+
+Maintenant que vous avez une branche de développement, ouvrez votre éditeur de texte et faites vos changements. Il est recommandé de faire beaucoup de petits commits dans votre branche. Ainsi, un changement qui crée un problème peut être plus facilement retracé et annulé si nécessaire. Pour faire un changement, éditez et sauvez n'importe quel fichier qui doit être mis à jour, ajoutez les à la *zone de staging* de Git, et commitez les vers votre branche:
+
+```bash
+git add path/to/updated_file
+git commit -m "My commit message."
+```
+
+`git add` ajoute les fichiers qui ont été changés dans la *zone de staging* de Git, qui est sa "zone de chargement". Elle contient tous les changements qui vont être *validés* (committed) par `git commit`, qui sauvegarde les changements vers le dépôt. Utilisez des messages de validation descriptifs afin que vous puissiez savoir ce qui a changé d'un coup d'oeil.
+
+!> Si vous changez beaucoup de fichiers, mais tous les fichiers font partie du même changement, vous pouvez utiliser `git add .` pour ajouter tous les fichiers changés dans le répertoire courant, plutôt que d'avoir à ajouter chaque fichiers individuellement.
+
+### Publier Vos Changements
+
+La dernière étape est de pousser vos changements vers votre fork. pour se faire, entrez `git push`. Git publie maintenant l'état courant de `dev_branch` vers votre fork.
+
+## Résoudre Les Conflits De Merge
+
+Parfois, lorsque votre travail sur une branche met beaucoup de temps à se compléter, des changements réalisés par d'autres peuvent entrer en conflit avec les changements que vous avez fait sur votre branche au moment où vous avez ouvert un pull request. Ceci est appelé un *conflit de merge*, et c'est ce qui arrive lorsque plusieurs personnes modifient les mêmes parties de mêmes fichiers.
+
+### Rebaser Vos Changements
+
+Un *rebase* est la manière pour Git de prendre les changements qui ont été faits à un point, les annuler, et les réappliquer sur un autre point. Dans le cas d'un conflit de merge, vous pouvez rebaser votre branche pour récupérer les changements qui ont été faits entre le moment où vous avez créé votre branche et le présent.
+
+Pour démarrer, lancez les commandes suivantes:
+
+```bash
+git fetch upstream
+git rev-list --left-right --count HEAD...upstream/master
+```
+
+La commande `git rev-list` retourne le nombre de commits qui diffère entre la branche courante et la branche master de QMK. Nous lançons `git fetch` en premier afin d'être sûr que les refs qui représentent l'état courant du dépôt upstream soient à jour. Le résultat de la commande `git rev-list` retourne deux nombres:
+
+```bash
+$ git rev-list --left-right --count HEAD...upstream/master
+7       35
+```
+
+Le premier nombre représente combien il y a eu de commits sur la branche courante depuis qu'elle a été créée, et le second nombre est combien de commits ont été faits sur la branche `upstream/master` depuis que la branche a été créée et, ainsi, les changements qui ne sont pas enregistrés sur la branche courante.
+
+Maintenant que l'état actuel de la branche courante et la branche upstream sont connus, nous pouvons maintenant démarrer une opération de rebase:
+
+```bash
+git rebase upstream/master
+```
+
+Ceci dit à Git d'annuler les commits de la branche courrante puis de les réappliquer sur la branche master de QMK.
+
+```bash
+$ 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".
+```
+
+Ceci nous dit que nous avons un conflit de merge, et nous donne le nom du fichier en conflit. Ouvez le fichier conflictuel dans votre éditeur de texte et, quelque part dans le fichier, vous trouverez quelque chose comme ça:
+
+```bash
+<<<<<<< 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 ligne `<<<<<<< HEAD` montre le début d'un conflit de merge et la ligne `>>>>>>> Commit #1` indique la fin, avec les sections conflictuelles séparées par `=======`. La partie du côté `HEAD` vient de la version du fichier provenant de la branche master de QMK, et la partie marquée avec le numéro du commit provient de la branche courrante.
+
+Parce que Git suis *les changements des fichiers*, plutôt que les contenus des fichiers directement, si Git ne peut pas trouver le texte qu'il y avait dans le fichier avant que le commit soit fait, il ne saura pas comment modifier le fichier. Modifier le fichier à nouveau va résoudre le conflit. Faites votre changement, et sauvez le fichier.
+
+```bash
+<p>Need help? Email support@webhost.us.</p>
+```
+
+Maintenant, lancez:
+
+```bash
+git add conflicting_file_1.txt
+git rebase --continue
+```
+
+Git enregistre le changement dans le fichier conflictuel, et continue à appliquer les commits depuis votre branche jusqu'à ce qu'il arrive à la fin.

docs/fr-FR/newbs_building_firmware.md

@@ -0,0 +1,81 @@
+# Compiler Votre Premier Firmware
+
+Maintenant que vous avez configuré votre environnement de build, vous être prêts à compiler un firmware customisé. Pour cette section, nous allons utiliser trois programmes différents: votre explorateur de fichier, votre éditeur de texte et votre fenêtre de terminal. Gardez les 3 ouverts jusqu'à ce que vous ayez terminé et soyez content de votre firmware de clavier.
+
+Si vous avez fermé et rouvert votre fenêtre de terminal depuis le démarrage de ce guide, n'oubliez pas de `cd qmk_firmware` afin que votre terminal soit dans le bon répertoire.
+
+## Naviguez vers votre répertoire keymaps
+
+Démarrez par naviguer dans le répertoire `keymaps` de votre clavier.
+
+?> Si vous êtes sous macOS ou Windows, il y a des commandes que vous pouvez utiliser pour facilement ouvrir le dossier keymaps.
+
+?> macOS:
+
+    open keyboards/<keyboard_folder>/keymaps
+
+?> Windows:
+
+    start .\\keyboards\\<keyboard_folder>\\keymaps
+
+## Créez une copie de la keymap `default`
+
+Une fois le dossier `keymaps` ouvert, créez une copie du répertoire `default`. Nous vous recommandons de nommer ce répertoire de la même manière que votre nom d'utilisateur GitHub. Vous pouvez aussi utiliser le nom que vous voulez, tant qu'il contient uniquement des lettres minuscules, des nombres et le caractère souligné (_).
+
+Afin d'automatiser ce processus, vous avez aussi l'option de lancer le script `new_keymap.sh`.
+
+Naviguez vers le répertoire `qmk_firmware/util` et tapez ce qui suit:
+
+```
+./new_keymap.sh <keyboard path> <username>
+```
+
+Par exemple, pour un utilisateur s'appeleant John, essayant de créer une nouvelle keymap pour le 1up60hse, il taperait:
+
+```
+./new_keymap.sh 1upkeyboards/1up60hse john
+```
+
+## Ouvrez `keymap.c` dans votre éditeur de texte préféré
+
+Ouvrez votre fichier `keymap.c`. Dans ce fichier, vous trouverez la structure qui contrôle comment votre clavier se comporte. En haut du fichier `keymap.c` il peut y avoir quelques `defines` et `enums` qui rendent la keymap plus simple à lire. Plus bas, vous trouverez une ligne telle que celle-ci:
+
+    const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+Cette ligne indique le début d'une liste de calques (layers). En dessous, vous trouverez des lignes contenant soit `LAYOUT`, soit `KEYMAP` et ces lignes indiquent le début d'un calque. En dessous de cette ligne se trouve la liste des touches qui comprennent ce calque particulier.
+
+!> Lorsque vous éditez votre fichier keymap, faites attention à ne pas ajouter ou enlever une virgule. Si vous le faites, vous aller empêcher votre firmware de compiler et il ne sera pas facile de trouver où la virgule est manquante ou en trop.
+
+## Customisez le layout à votre goût
+
+Libre à vous de choisir comment compléter cette étape. Faites le petit changement qui vous dérange ou retravaillez tout de zéro. Vous pouvez supprimer des calques si vous ne les utilisez pas tous, ou ajouter des calques jusqu'à un maximum de 32. Vérifiez la documentation suivante pour trouver ce que vous pouvez définir ici:
+
+* [Keycodes](keycodes.md)
+* [Fonctionnalités](features.md)
+* [FAQ](faq.md)
+
+?> Lorsque vous découvrez comment des keymaps fonctionnent, faites de petits changements. De gros changements rendent le débuggage des problèmes éventuels plus difficile.
+
+## Compilez votre firmware
+
+Lorsque les changements de votre keymap sont complets, vous allez devoir compiler le firmware. Pour ce faire, retournez à votre terminal et lancez la commande de compilation:
+
+    make <my_keyboard>:<my_keymap>
+
+Par exemple, si votre keymap s'appelle "xyverz" et vous compilez une keymap pour une plank rev5, vous allez utiliser cette commande:
+
+    make planck/rev5:xyverz
+
+Durant la compilation, vous allez avoir beaucoup de messages sur l'écran vous informant de quels fichiers sont en train d'être compilés. Il devrait se terminer avec des messages qui ressemblent comme suit:
+
+```
+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
+```
+
+## Flasher votre firmware
+
+Allez sur la page [Flasher le firmware](fr-FR/newbs_flashing.md) pour apprendre comment écrire votre nouveau firmware sur votre clavier.

docs/fr-FR/newbs_building_firmware_configurator.md

@@ -0,0 +1,105 @@
+# Configurateur de QMK
+
+Le [Configurateur de QMK](https://config.qmk.fm) est une interface graphique en ligne permettant de générer des fichiers "hex" du firmware de QMK.
+
+?> **S'il vous plaît, suivez les étapes suivantes dans l'ordre.**
+
+Regardez le [Tutoriel vidéo](https://youtu.be/tx54jkRC9ZY)
+
+Le configurateur de QMK fonctionne mieux avec Chrome et Firefox.
+
+!> **Les fichiers d'autres outils, tels que KLE ou kbfirmware ne seront pas compatibles avec le configurateur QMK. Ne les chargez pas, ne les importez pas. Le configurateur QMK est un outil DIFFERENT.**
+
+## Sélectionner votre clavier
+
+Cliquez la boîte déroulante et sélectionnez le clavier pour lequel vous voulez créer une keymap.
+
+?> Si votre clavier a plusieurs versions, faites attention à utiliser la bonne.
+
+Je vais le répéter, parce que c'est important
+
+!> **FAITES ATTENTION A UTILISER LA BONNE VERSION !**
+
+Si votre clavier est annoncé comme fonctionnant grâce à QMK mais n'est pas dans la liste, il y a des chances que le développeur ne l'ait pas encore fait, ou que nous n'avons pas encore eu le temps de le merger. Ajoutez un problème (issue) sur [qmk_firmware](https://github.com/qmk/qmk_firmware/issues) demandant le support de votre clavier, s'il n'y a pas de [Pull Request](https://github.com/qmk/qmk_firmware/pulls?q=is%3Aopen+is%3Apr+label%3Akeyboard) ouvert pour lui. Il y a aussi des clavier alimentés par QMK qui sont sur le compte GitHub du fabriquant, il est bon de le vérifier aussi.
+
+## Sélectionner la disposition de votre clavier
+
+Choisissez la disposition (layout) qui représente le mieux la keymap que vous voulez créer. Certains clavier n'ont pas encore assez de dispositions ou des dispositions incorrectes. Ils seront supportés dans le future.
+
+## Nom de la Keymap
+
+Appelez cette keymap comme vous voulez.
+
+?> Si vous rencontrez des problèmes lors de la compilation, il peut être utile de changer ce nom, il peut déjà exister dans le dépôt du firmware QMK.
+
+## Créer votre keymap
+
+Entrer un keycode peut s'accomplir de 3 façons différentes.
+
+1. Glisser déposer
+2. Cliquer sur un endroit vide sur le layout et cliquer sur le keycode souhaité
+3. Cliquer sur un endroit vide sur le layout et appuyer sur une touche physique de votre clavier.
+
+Passez votre souris au dessus d'une touche et un affichage vous dira quel est le rôle du keycode. Pour une version plus verbeuse suivre:
+
+[Référence Keycode basique](https://docs.qmk.fm/#/keycodes_basic)
+[Référence Keycode avancé](https://docs.qmk.fm/#/feature_advanced_keycodes)
+
+Dans le cas où vous ne trouvez pas une disposition qui supporte votre keymap, par exemple trois places pour une barre d'espace, ou deux places pour retour clavier, ou deux places pour shift, etc. etc. remplissez les TOUTES.
+
+### Exemples
+
+3 places pour la barre d'espace: Remplissez les TOUTES avec la barre d'espace
+
+2 places pour un retour clavier: Remplissez les DEUX avec un retour clavier
+
+2 places pour un shift droit: Remplissez les DEUX avec un shift droit
+
+1 place pour un shift gauche et 1 place pour le support ISO: Remplissez les deux avec un shift gauche
+
+5 places, mais seulement 4 touches: Deviner et vérifier, ou demander à quelqu'un qui l'a déjà fait.
+
+## Sauvez votre keymap pour des éditions futures
+
+Une fois satisfait de votre keymap, ou si vous souhaitez revenir travailler dessus plus tard, appuyez sur le bouton `Export Keymap`. Il vous permettra de sauvegarder votre keymap avec le nom choisi au dessus suivi de .json.
+
+Vous pouvez ensuite charger ce fichier .json à nouveau en appuxant sur le bouton `Import Keymap`.
+
+!> **ATTENTION** Ce n'est pas le même type de fichier .json utilisé pour kbfirmware.com ou n'importe quel autre outil. Si vous essayez d'utiliser ce fichier pour d'autres outil, ou le fichier .json d'autres outils avec le configurateur QMK, il y a des chances que votre clavier **explose**.
+
+## Générer votre fichier firmware
+
+Appuyez sur le bouton `Compile`.
+
+Une fois la compilation terminée, vous pourrez appuyer sur le bouton vert `Download Firmware`.
+
+## Ecrire votre firmware sur votre clavier
+
+Merci de vous référer à [Flasher le Firmware](fr-FR/newbs_flashing.md)
+
+## Dépannage
+
+#### Mon fichier json ne fonctionne pas
+
+Si le fichier .json a été généré par le configurateur QMK, bravo vous avez trouvé un bug. Merci d'ouvrir une issue sur [qmk_configurator](https://github.com/qmk/qmk_configurator/issues)
+
+Sinon... vous avez raté mon message écris en gras qui dit de ne pas utiliser d'autres fichiers .json?
+
+#### Il y a des espaces en trop dans mon alyout? Qu'est-ce que je fais?
+
+Si vous voulez dire que vous avez trois places pour une barre d'espace, le mieux est de les remplir tous avec une barre d'espace. Vous pouvez faire de même avec les retour clavier et les shift.
+
+#### C'est quoi le keycode pour .......
+
+Merci de regarder
+
+[Référence keycode basique](https://docs.qmk.fm/#/keycodes_basic)
+[Référence keycode avancé](https://docs.qmk.fm/#/feature_advanced_keycodes)
+
+#### Ca ne compile pas?
+
+Merci de vérifier les autres dispositions de votre keymap afin d'être sûr qu'il n'y a pas de touches aléatoires.
+
+## Problèmes et Bugs
+
+Nous acceptons toujours les demandes des clients et les rapports de bugs. Merci de les remplirs sur [qmk_configurator](https://github.com/qmk/qmk_configurator/issues)

docs/fr-FR/newbs_flashing.md

@@ -0,0 +1,348 @@
+# Flasher votre clavier
+
+Maintenant que vous avez compilé un firmware custom, vous allez vouloir le flasher dans votre clavier.
+
+## Flasher votre clavier avec QMK Toolbox
+
+La manière la plus simple de flasher votre clavier est avec [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases).
+
+Toutefois, la QMK Toolbox n'est actuellement disponible que pour Windows et macOS. Si vous utilisez Linux (ou préférez flasher le firmware depuis la ligne de commande), vous devrez utiliser [la métode décrite ci-dessous](newbs_flashing.md#flash-your-keyboard-from-the-command-line).
+
+### Charger le fichier dans QMK Toolbox
+
+Démarrez en ouvrant l'application QMK Toolbox. Cherchez le fichier de firmware dans Finder ou Explorer. Vore firmware de clavier peut être dans un de deux formats `.hex` ou `.bin`. QMK essaye de copier le bon format pour votre clavier du répertoire racine `qmk_firmware`.
+
+?> Si vous êtes sous Windows ou macOS il y a des commandes que vous pouvez utiliser pour facilement ouvrir le répertoire firmware dans Explorer ou Finder.
+
+?> Windows:
+
+    start .
+
+?> macOS:
+
+    open .
+
+Le fichier firmware suit toujours ce format de nommage:
+
+    <keyboard_name>_<keymap_name>.{bin,hex}
+
+Par exemple, le `plank/rev5` avec une keymap `default` aura ce nom de fichier:
+
+    planck_rev5_default.hex
+
+Une fois que vous aurez trouvé votre fichier de firmware, glissez le dans la boîte "Local file" sur QMK Toolbox, ou cliquez sur "Open" et naviguez où votre firmware est enregistré.
+
+### Mettez votre clavier en mode DFU (Bootloader)
+
+Afin de flasher votre firmware custom, vous devez mettre votre clavier dans un mode spécial. Lorsqu'il sera dans ce mode, vous ne pourrez pas taper ou utiliser votre clavier. Il est très important que vous ne débranchiez pas votre clavier ou n'arrêtiez pas le processus d'écriture du firmware.
+
+Chaque clavier a une manière différente d'entrer dans ce mode spécial. Si votre clavier tourne actuellement QMK ou TMK et vous n'avez pas reçu d'instruction spécifiques, essayez, dans cet ordre:
+
+* Enfoncez les deux touches shift et appuyez sur `Pause`
+* Enfoncez les deux touches shift et appuyez sur `B`
+* Débranchez votre clavier, gardez shift la barre d'espace et `B` en même temps, branchez votre clavier et attendez une seconde avant de relâcher les touches.
+* Appuyez la touche physique `RESET` en bas du PCB
+* Trouvez les pins sur le PCB marquées `BOOT0` ou `RESET`, court circuitez ces pins en branchant votre PCB
+
+Lorsque vous aurez réussi, vous verrez le message suivant dans QMK Toolbox:
+
+```
+*** Clueboard - Clueboard 66% HotSwap disconnected -- 0xC1ED:0x2390
+*** DFU device connected
+```
+
+### Flasher votre clavier
+
+Appuyez sur le boutton `Flash` dans QMK Toolbox. Vous verrez un résultat similaire à ce qui suit:
+
+```
+*** 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
+```
+
+## Flashez votre clavier à l'aide de la ligne de commande
+
+La première chose que vous devez savoir c'est quel bootloader utilise votre clavier. Il y a quatre bootloaders principaux. Pro-Micro et les clones, utilisent CATERINA, les Teensy utilisent Halfkay, les OLKB utilisent QMK-DFU et les autres chips atmega32u4 utilisent DFU.
+
+Vous pouvez trouver plus d'information à propos des bootloaders sur la page [Instructions de flash et information sur le Bootloader](flashing.md).
+
+Si vous savez quel bootloader vous utilisez, lorsque vous compilez le firmware, vous pouvez ajouter quelques options à la commande `make` pour automatiser le processus de flash.
+
+### DFU
+
+Pour le bootloader DFU, lorsque vous êtes prêts à compiler et flasher votre firmware, ouvrez votre fenêtre de terminal et lancez la commande de compilation:
+
+    make <my_keyboard>:<my_keymap>:dfu
+
+Par exemple, si vous keymap s'appelle "xyverz" et vous compilez une keymap pour une plank rev5, vous utiliserez cette commande:
+
+    make planck/rev5:xyverz:dfu
+
+Une fois la compilation terminée, le résultat devrait être le suivant:
+
+```
+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
+ ```
+
+Une fois arrivé à ce stade, le script de compilation va checher le bootloader DFU toutes les 5 secondes. Il va répéter les messages suivants jusqu'à ce que l'appareil soit trouvé ou que vous l'annuliez.
+
+    dfu-programmer: no device present.
+    Error: Bootloader not found. Trying again in 5s.
+
+Une fois terminé, vous devrez mettre à zéro le contrôleur. Vous allez voir un résultat similaire à ceci:
+
+```
+*** 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 vous avez des soucis concerant ceci - comme par exemple `dfu-programmer: no device present` - merci de regarder [Foires Aux Questions de Compilation](faq_build.md).
+
+#### Commandes DFU
+
+Il y  aun certain nombre de commandes du DFU que vous pouvez utiliser pour flasher un firmware sur un device DFU:
+
+* `:dfu` - C'est l'option standard qui attends jusqu'à e qu'un appareil DFU soit disponible, puis flash le firmware. Il va vérifier toutes les 5 secondes, afin de voir si un appareil DFU est apparu.
+* `:dfu-ee` - Ceci flash un fichier `eep` à la place du standard hex, peu commun.
+* `:dfu-split-left` - Ceci flash le firmware standard, comme la commande standard (`:dfu`). Toutefois, elle flash aussi les fichiers EEPROM du "côté gauche" pour les claviers scindés. _C'est l'option idéale pour les claviers scindés basés sur Elite C._
+* `:dfu-split-right` - Ceci flash le firmware standard, comme la commande standard (`:dfu`). Toutefois, elle flash aussi les fichiers EEPROM du "côté droit" pour les claviers scindés. _C'est l'option idéale pour les claviers scindés basés sur Elite C._
+
+### Caterina
+
+Pour les boards Arduino et leurs clones (tel que le SparkFun ProMicro), lorsque vous êtes prêt à compiler et flasher votre firmware, ouvrez votre terminal et lancer la commande de compilation:
+
+    make <my_keyboard>:<my_keymap>:avrdude
+
+Par exemple, si votre keymap se nomme "xyverz" et que vous compilez une keymap pour un Lets Split rev2, vous utiliserez la commande suivante:
+
+    make lets_split/rev2:xyverz:avrdude
+
+Une fois le firmware compilé, vous aurez le résultat suivant:
+
+```
+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..............
+```
+
+Une fois ceci fait, réinitialisez votre board et le script va détecter et flasher le firmware. La sortie devrait ressember à quelque chose comme ça:
+
+```
+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 vous avez un soucis, essayez de faire ceci:
+
+    sudo make <my_keyboard>:<my_keymap>:avrdude
+
+En addition, si vous voulez flasher plusieurs boards, utilisez la commande suivante:
+
+    make <keyboard>:<keymap>:avrdude-loop
+
+Une fois que vous avez terminé de flasher des boards, vous devrez appuyer sur Ctrl + C, ou les touches correspondantes pour votre système d'exploitation pour arrêter la boucle.
+
+### HalfKay
+
+Pour les composants PJRC (les Teensy), lorsque vous êtes prêts à compiler et flasher votre firmware, ouvrez votre fenêtre de terminal et lancez la commande de compilation suivante:
+
+    make <my_keyboard>:<my_keymap>:teensy
+
+Par exemple, si vous keymap s'appelle "xyverz" et vous compilez une keymap pour un Ergodox ou un Ergodox EZ, vous utiliserez cette commande:
+
+    make ergodox_ez:xyverz:teensy
+
+Une fois la compilation du firmware terminée, votre sortie devrait ressembler à ça:
+
+```
+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)
+ ```
+
+Une fois terminé, réinitialisez votre board. Une fois fait, vous verrez une sortie comme ça:
+
+ ```
+ Found HalfKay Bootloader
+Read "./.build/ergodox_ez_xyverz.hex": 28532 bytes, 88.5% usage
+Programming............................................................................................................................................................................
+...................................................
+Booting
+```
+
+### BootloadHID
+
+Pour les boards basée sur Bootmapper Client(BMC)/bootloadHID/ATmega32A, une fois prêt à compiler et flasher le firmware, ouvrez votre fenêtre de terminal et lancez la commande suivante:
+
+    make <my_keyboard>:<my_keymap>:bootloaderHID
+
+Par exemple, si votre keymap s'appelle "xyverz" et que vous compilez une keymap pour un jj40, vous utilisez cette commande:
+
+    make jj40:xyverz:bootloaderHID
+
+Une fois le firmware compilé, vous aurez cette sortie:
+
+```
+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)
+```
+
+A ce stade, le script de build va chercher le bootloader DFU toutes les 5 secondes. Il va répéter la sortie suivante jusqu'à ce que le dispositif soit trouvé ou que vous l'annuliez.
+
+```
+Error opening HIDBoot device: The specified device was not found
+Trying again in 5s.
+```
+
+Une fois ce résultat atteint, réinitialisez le contrôleur. Il devrait afficher le résultat suivant:
+
+```
+Page size   = 128 (0x80)
+Device size = 32768 (0x8000); 30720 bytes remaining
+Uploading 22016 (0x5600) bytes starting at 0 (0x0)
+0x05580 ... 0x05600
+```
+
+### STM32 (ARM)
+
+Pour la majorité des boards ARM (incluant les Proton C, Planck Rev 6, et Preonic Rev 3), lorsque vous êtes prêt à compiler et flasher votre firmware,ouvrez la fenêtre de terminal et lancez la commande de compilation:
+
+    make <my_keyboard>:<my_keymap>:dfu-util
+
+Par exemple, si votre keymap s'appelle "xyverz" et vous compilez une keymap pour le clavier Plank Revision 6, vous utiliserez cette commande et redémarrerez le clavier vers le bootloader (avant que la compilation soit terminée):
+
+    make planck/rev6:xyverz:dfu-util
+
+Une fois le firmware compilé, il va afficher quelque chose comme ça:
+
+```
+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
+```
+
+#### Commandes STM32
+
+Il y  aun certain nombre de commandes du DFU que vous pouvez utiliser pour flasher un firmware sur un device STM32:
+
+* `:dfu-util` - C'est l'option standard pour flasher un appareil STM32.
+* `:dfu-util-wait` - Ceci fonctionne comme la commande standard, mais permet de d'avoir une pause (configurable( de 10 secondes avant de flasher le fimrware. Vous pouvez utiliser `TIME_DELAY=20` à la ligne de commande pour changer le délai.
+* `:dfu-util-left` - Ceci flasher le firmware standard, comme la commande standard (`:dfu-util`). Toutefois, elle flasher aussi les fichiers EEPROM du "côté gauche" pour les claviers scindés.
+* `:dfu-util-right` - Ceci flash le firmware standard, comme la commande standard (`:dfu-util`). Toutefois, elle flash aussi les fichiers EEPROM du "côté droit" pour les claviers scindés.
+
+## Faites l'essai!
+
+Bravo! Votre firmware customisé a été programmé sur votre clavier!
+
+Essayez-le et vérifiez qu'il fonctionne comme vous le souhaitez. Nous avons écrit [Tester et débugger](newbs_testing_debugging.md) pour compléter le guide du débutant, alors allez voir là-bas pour apprendre comment dépanner vos fonctionnalités custom.

docs/fr-FR/newbs_getting_started.md

@@ -0,0 +1,101 @@
+# Introduction
+
+Votre clavier d'ordinateur contient un processeur, proche de celui dans votre ordinateur. Ce processeur exécute un logiciel responsable de détecter les touches appuyées et envoie des rapports à propos de l'état du clavier lorsque les touches sont appuyées et relâchées. QMK prend le rôle de ce logiciel, détectant les appuis des boutons et passant cette information à l'ordinateur hôte. Lorsque vous construisez votre keymap customisée, vous créez l'équivalent d'un programme exécutable pour votre clavier.
+
+QMK essaie de rendre les choses simples faciles, et les choses difficiles possibles. Vous n'avez pas à savoir programmer pour créer des keymaps puissantes - vous devez seulement suivre quelques rêgles de syntaxe simples.
+
+# Guide de démarrage
+
+Avant de pouvoir construire des keymaps, vous devez installer quelques logiciels et configurer votre environnement de compilation. Ceci n'a besoin d'être fait seulement une fois, peu importe le nombre de clavier pour lesquels vous compter compiler un firmware.
+
+Si vous préférez une approche plus proche d'une interface graphique, considérez utiliser l'outil en ligne [QMK Configurator](https://config.qmk.fm). Référez vous à [Construire votre premier firmware en utilisant l'interface graphique en ligne](newbs_building_firmware_configurator.md).
+
+## Logiciels à télécharger
+
+### Editeur de texte
+
+Vous allez avoir besoin d'un programme qui peut éditer et sauvegarder des fichier **plain text**. Si vous êtes sur Windows, vous pouvez utiliser notepad et sur Linux vous pouvez utiliser gedit. Ces deux options sont des éditeurs de texte simples mais fonctionnels. Sur macOS, faites attention avec l'application par défaut TextEdit: elle ne sauvegardera pas les fichiers en mode "plain text" sauf si vous sélectionnez explicitement _Make Plain Text_ à partir du menu _Format_.
+
+Vous pouvez aussi télécharger et installer un éditeur de texte dédié comme [Sublime Text](https://www.sublimetext.com/) ou [VS Code](https://code.visualstudio.com/). C'est probablement la meilleure solution peu importe la plateforme car ce sont des programmes conçus spécifiquement pour éditer du code.
+
+?> Pas sûr de quel éditeur de texte utiliser? Laurence Bradford a écrit une [excellente introduction](https://learntocodewith.me/programming/basics/text-editors/) au sujet.
+
+### QMK Toolbox
+
+QMK Toolbox est un programme graphique optionnel pour Windows et macOS qui permet à la fois de programmer et débugger votre clavier customisé. Il vous sera probablement très utile pour facilement flasher votre clavier et analyser ses messages de débugage.
+
+[Télécharger la dernière version ici.](https://github.com/qmk/qmk_toolbox/releases/latest)
+
+* Pour Windows: `qmk_toolbox.exe` (portable) or `qmk_toolbox_install.exe` (installeur)
+* Pour macOS: `QMK.Toolbox.app.zip` (portable) or `QMK.Toolbox.pkg` (installeur)
+
+## Configurez votre environnement
+
+Nous avons essayé de rendre QMK aussi simple que possible à configurer. Vous avez uniquement à préparer votre environnment Linux ou Unix et laisser QMK installer le reste.
+
+?> Si vous n'avez jamais travailé avec la lignde commande Linux/Unix, il y a un certain nombre de concepts basiques et de commandes que vous devriez apprendre. Ces ressources vous apprendrons suffisemment pour travailler avec QMK:<br>
+[Commandes Linux à savoir](https://www.guru99.com/must-know-linux-commands.html)<br>
+[Commandes Unix de base](https://www.tjhsst.edu/~dhyatt/superap/unixcmd.html)
+
+### Windows
+
+Vous devez installer MSYS2 et Git.
+
+* Suivez les instructions d'installation sur la [page de MSYS2](http://www.msys2.org).
+* Fermez tous les terminaux MSYS2 éventuellement ouverts et ouvrez un nouveau terminal MSYS2 MinGW 64-bit.
+* Installez Git en lançant la commande: `pacman -S git`.
+
+### macOS
+
+Vous devez installer Homebew. Suivez les instructions sur la [page de Homebrew](https://brew.sh).
+
+Une fois Homebrew installé, continuez avec _Configurer QMK_. Dans cete étape, nous lancerons un script qui va installer d'autres paquets.
+
+### Linux
+
+Vous devez installer Git. Il est très probable que vous l'ayez déjà installé, mais sinon, une des commandes suivantes devrait l'installer:
+
+* Debian / Ubuntu / Devuan: `apt-get install git`
+* Fedora / Red Hat / CentOS: `yum install git`
+* Arch: `pacman -S git`
+
+?> Docker est aussi une option sur toutes les plateformes. [Appuyez ici pour plus de détail.](getting_started_build_tools.md#docker)
+
+## Configurer QMK
+
+Une fois votre environnement Linux/Unix configuré, vous êtes prêt à télécharger QMK. Nous allons le faire en utilisant Git pour "cloner" le dépôt de QMK. Ouvrez un terminal ou une fenêtre MSYS2 MinGW et gardez le ouvert pour le reste de ce guide. Dans ce terminal, lancez ces deux commandes:
+
+```shell
+git clone --recurse-submodules https://github.com/qmk/qmk_firmware.git
+cd qmk_firmware
+```
+
+?> Si vous savez déjà [comment utiliser GitHub](getting_started_github.md), nous recommandons que vous créez et clonez votre propre fork. Si vous ne savez pas ce que cela veut dire, vous pouvez sans problème ignorer ce message.
+
+QMK vient avec un script pour vous aider à configurer le reste de ce que vous aurez besoin. Vous devez le lancer en tapant la ligne de commande suivante:
+
+    util/qmk_install.sh
+
+## Testez votre environnement de compilation
+
+Maintenant que votre environnement de compilation de QMK est configuré, vous pouvez compiler un firmware pour votre clavier. Démarrez en compilant la keymap par défaut du clavier. Vous devriez pouvoir le faire avec une commande de ce format:
+
+    make <keyboard>:default
+
+Par exemple, pour compiler un firmware pour une Clueboard 66%, vous utiliserez:
+
+    make clueboard/66/rev3:default
+
+Une fois ceci fait, vous devriez avoir beaucoup d'information dans votre sortie qui devrait se terminer par quelque chose de similaire à ça:
+
+```
+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)
+```
+
+# Créer votre Keymap
+
+Vous êtes maintenant prêt à créer votre propre keymap! Passez à l'étape [Compiler votre premier firmware](newbs_building_firmware.md) pour ce faire.

docs/fr-FR/newbs_learn_more_resources.md

@@ -0,0 +1,14 @@
+# Ressources d'apprentissage
+
+Ces ressources permettent de donner aux nouveaux membres de la communauté QMK plus de compréhension aux informations données dans la documentation Newbs.
+
+Ressources Git:
+
+* [Tutoriel général](https://www.codecademy.com/learn/learn-git)
+* [Jeu Git pour apprendre avec des exemples](https://learngitbranching.js.org/)
+* [Des ressources Git pour en savoir plus à propos de GitHub](getting_started_github.md)
+* [Des ressources Git spécifiques à QMK](contributing.md)
+
+Ressources sur les lignes de commande:
+
+* [Bon tutoriel général sur la ligne de commande](https://www.codecademy.com/learn/learn-the-command-line)

docs/fr-FR/newbs_testing_debugging.md

@@ -0,0 +1,101 @@
+# Test et débugage
+
+Une fois votre clavier configuré avec un firmware custom, vous êtes prêt à le tester. Avec un peu de chance, tout fonctionne parfaitement bien, dans le cas contraire, ce document vous aidera à trouver où se trouve le problème.
+
+## Tester
+
+Tester votre clavier est normalement assez simple. Appuyez chaque touche de votre clavier et assurez vous qu'il envoie les touches auquel vous vous attendiez. Il existe même des programmes qui vous aideront à vérifier qu'aucune touche ne soit oubliée.
+
+Note: ces programmes ne sont ni fournis ni approuvés par QMK.
+
+* [Switch Hitter](https://elitekeyboards.com/switchhitter.php) (Windows seulement)
+* [Keyboard Viewer](https://www.imore.com/how-use-keyboard-viewer-your-mac) (Mac seulement)
+* [Keyboard Tester](http://www.keyboardtester.com) (Web)
+* [Keyboard Checker](http://keyboardchecker.com) (Web)
+
+## Débuguer
+
+Votre clavier va envoyer des informations de débugage si vous avez `CONSOLE_ENABLE = yes` dans votre fichier `rules.mk`. Par défaut, la sortie est très limitée, mais vous pouvez activer le mode debug pour augmenter la quantité de sortie de débugage. Utilisez le keycode `DEBUG` dans votre keymap, utilisez la fonction [Commande](feature_command.md) pour activer le mode debug ou ajoutez le code suivant à votre 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;
+}
+```
+
+### Débuguer avec QMK Toolbox
+
+Pour les plateformes compatibles, [QMK Toolbox](https://github.com/qmk/qmk_toolbox) peut être utilisé pour afficher les message de débugage pour votre clavier.
+
+### Débuguer avec hid_listen
+
+Vous préférez une solution basée sur le terminal? [hid_listen](https://www.pjrc.com/teensy/hid_listen.html), fourni par PJRC, peut aussi être utilisé pour afficher des messages de débugage. Des versions compilées pour Windows, Linux et MacOS sont disponibles.
+
+<!-- FIXME: Describe the debugging messages here. -->
+
+## Envoyer vos propres messages de débugage
+
+Parfois, il est utile d'afficher des messages de débugage depuis votre [code custom](custom_quantum_functions.md). Le faire est assez simple. Commencez par ajouter `print.h` au début de votre fichier:
+
+    #include <print.h>
+
+Une fois fait, vous pouvez utiliser les fonctions print suivantes:
+
+* `print("string")`: Affiche une simple chaîne de caractères.
+* `uprintf("%s string", var)`: Affiche une chaîne de caractères formattée.
+* `dprint("string")` Affiche une chaîne de caractère simple, mais uniquement lorsque le mode debug est activé.
+* `dprintf("%s string", var)`: Affiche une chaîne de caractère formattée, mais uniquement lorsque le mode debug est activé.
+
+## Exemples de debugage
+
+Si dessous se trouve une liste d'exemples réels de débugage. Pour plus d'information, référez-vous à [Débuguer/Dépanner QMK](faq_debug.md).
+
+### A quelle position de la matrice se trouve cette activation de touche?
+
+Lors du portage ou lorsque vous essayez de diagnostiquer un problème de PCB, il est utile de savoir si une activation de touche est enregistrée correctement. Pour activer le log de ce scénario, ajoutez le code suivant à votre fichier keymaps `keymap.c`.
+
+```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;
+}
+```
+
+Exemple de sortie
+
+```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
+```
+
+### Combien de temps cela a pris pour une activation de touche?
+
+Lorsque vous testez des problèmes de performance, il peut être utile de savoir à quelle fréquence la matrice est scannée. Pour activer le log dans ce scénario, ajoutez la ligne suivante à votre fichier `config.h` de votre keymaps.
+
+```c
+#define DEBUG_MATRIX_SCAN_RATE
+```
+
+Exemple de sortie
+
+```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/internals_gpio_control.md

@@ -6,18 +6,17 @@ QMK has a GPIO control abstraction layer which is microcontroller agnostic. This
 
 The following functions can provide basic control of GPIOs and are found in `quantum/quantum.h`.
 
-|Function              |Description                                                       |
+|Function              |Description                                                       | Old AVR Examples                               | Old ChibiOS/ARM Examples                        |
-|----------------------|------------------------------------------------------------------|
+|----------------------|------------------------------------------------------------------|------------------------------------------------|-------------------------------------------------|
-|`setPinInput(pin)`    |Set pin as input with high impedance (High-Z)                     |
+|`setPinInput(pin)`    |Set pin as input with high impedance (High-Z)                     | `DDRB &= ~(1<<2)`                              | `palSetLineMode(pin, PAL_MODE_INPUT)`           |
-|`setPinInputHigh(pin)`|Set pin as input with build in pull-up                            |
+|`setPinInputHigh(pin)`|Set pin as input with builtin pull-up resistor                    | `DDRB &= ~(1<<2); PORTB \|= (1<<2)`             | `palSetLineMode(pin, PAL_MODE_INPUT_PULLUP)`    |
-|`setPinInputLow(pin)` |Set pin as input with build in pull-down (Supported only on STM32)|
+|`setPinInputLow(pin)` |Set pin as input with builtin pull-down resistor                  | N/A (Not supported on AVR)                     | `palSetLineMode(pin, PAL_MODE_INPUT_PULLDOWN)`  |
-|`setPinOutput(pin)`   |Set pin as output                                                 |
+|`setPinOutput(pin)`   |Set pin as output                                                 | `DDRB \|= (1<<2)`                               | `palSetLineMode(pin, PAL_MODE_OUTPUT_PUSHPULL)` |
-|`writePinHigh(pin)`   |Set pin level as high, assuming it is an output                   |
+|`writePinHigh(pin)`   |Set pin level as high, assuming it is an output                   | `PORTB \|= (1<<2)`                              | `palSetLine(pin)`                               |
-|`writePinLow(pin)`    |Set pin level as low, assuming it is an output                    |
+|`writePinLow(pin)`    |Set pin level as low, assuming it is an output                    | `PORTB &= ~(1<<2)`                             | `palClearLine(pin)`                             |
-|`writePin(pin, level)`|Set pin level, assuming it is an output                           |
+|`writePin(pin, level)`|Set pin level, assuming it is an output                           | `(level) ? PORTB \|= (1<<2) : PORTB &= ~(1<<2)` | `(level) ? palSetLine(pin) : palClearLine(pin)` |
-|`readPin(pin)`        |Returns the level of the pin                                      |
+|`readPin(pin)`        |Returns the level of the pin                                      | `_SFR_IO8(pin >> 4) & _BV(pin & 0xF)`          | `palReadLine(pin)`                              |
 
 ## Advanced Settings
 
 Each microcontroller can have multiple advanced settings regarding its GPIO. This abstraction layer does not limit the use of architecture-specific functions. Advanced users should consult the datasheet of their desired device and include any needed libraries. For AVR, the standard avr/io.h library is used; for STM32, the ChibiOS [PAL library](http://chibios.sourceforge.net/docs3/hal/group___p_a_l.html) is used.
-

docs/newbs_building_firmware.md

@@ -8,15 +8,15 @@ If you have closed and reopened your terminal window since following the first p
 
 Start by navigating to the `keymaps` folder for your keyboard.
 
-?> If you are on macOS or Windows there are commands you can use to easily open the keymaps folder.
+If you are on macOS or Windows there are commands you can use to easily open the keymaps folder.
 
-?> macOS:
+### macOS:
 
-    open keyboards/<keyboard_folder>/keymaps
+``` open keyboards/<keyboard_folder>/keymaps ```
 
-?> Windows:
+### Windows:
 
-    start .\\keyboards\\<keyboard_folder>\\keymaps
+``` start .\\keyboards\\<keyboard_folder>\\keymaps ```
 
 ## Create a Copy Of The `default` Keymap
 

drivers/issi/is31fl3733.c

@@ -231,5 +231,6 @@ void IS31FL3733_update_led_control_registers(uint8_t addr, uint8_t index) {
             IS31FL3733_write_register(addr, i, g_led_control_registers[index][i]);
         }
     }
-    g_led_control_registers_update_required[index] = false;
+    // This seems counter intuitive but sometimes this page can get corrupted. So update it every time.
+    // g_led_control_registers_update_required[index] = false;
 }

keyboards/40percentclub/gherkin/keymaps/talljoe-gherkin/keymap.c

@@ -30,7 +30,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   ),
 
   [_RAISE] = LAYOUT_ortho_3x10(
-    KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_7,    KC_9,    KC_0,
+    KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,
     KC_ESC,  KC_MINS, KC_EQL,  _______, KC_LBRC, KC_RBRC, _______, KC_QUOT, KC_SCLN, _______,
     OS_LCTL, OS_LGUI, OS_LALT, KC_GRV,  _______, KC_TAB,  KC_BSLS, KC_COMM, KC_DOT,  KC_SLSH
   ),

keyboards/40percentclub/mf68/keymaps/emdarcher/keymap.c

@@ -43,13 +43,13 @@ void led_set_user(uint8_t usb_led){
         //set led pins to low
         setPinOutput(B0);
         writePinLow(B0);
-        setPinOutput(B5);
+        setPinOutput(D5);
-        writePinLow(B5);
+        writePinLow(D5);
     } else {
         //set to Hi-Z
         setPinInput(B0);
         writePinLow(B0);
-        setPinInput(B5);  
+        setPinInput(D5);
-        writePinLow(B5);
+        writePinLow(D5);
     }
 }

keyboards/abstract/ellipse/rev1/rules.mk

@@ -1,63 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = atmel-dfu
 
-
-# If you don't know the bootloader type, then you can specify the
-# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
-#   Teensy halfKay      512
-#   Teensy++ halfKay    1024
-#   Atmel DFU loader    4096
-#   LUFA bootloader     4096
-#   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   change yes to no to disable
 #

keyboards/acr60/rules.mk

@@ -1,45 +1,15 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
+BOOTLOADER = atmel-dfu
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
 
 # Build Options
 #   comment out to disable the options.

keyboards/adkb96/rules.mk

@@ -1,58 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
- #   atmega32a    bootloadHID 
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = caterina
 
-# Boot Section Size in *bytes*
-#   Teensy halfKay   512
-#   Teensy++ halfKay 1024
-#   Atmel DFU loader 4096
-#   LUFA bootloader  4096
-#   USBaspLoader     2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
 # Build Options
 #   change to "no" to disable the options, or define them in the Makefile in
 #   the appropriate keymap folder that will get included automatically

keyboards/aeboards/aegis/rules.mk

@@ -1,50 +1,16 @@
-# project specific files
-SRC =	keyboards/wilba_tech/wt_main.c
-		
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section
 BOOTLOADER = atmel-dfu
 
-
 # Build Options
 #   change yes to no to disable
 #
@@ -63,3 +29,6 @@ UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
+
+# project specific files
+SRC = keyboards/wilba_tech/wt_main.c

keyboards/aeboards/ext65/rules.mk

@@ -1,50 +1,16 @@
-# project specific files
-SRC =	keyboards/wilba_tech/wt_main.c
-		
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section
 BOOTLOADER = atmel-dfu
 
-
 # Build Options
 #   change yes to no to disable
 #
@@ -63,3 +29,6 @@ UNICODE_ENABLE = no         # Unicode
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
+
+# project specific files
+SRC += keyboards/wilba_tech/wt_main.c

keyboards/ai03/lunar/rules.mk

@@ -1,63 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = atmel-dfu
 
-
-# If you don't know the bootloader type, then you can specify the
-# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
-#   Teensy halfKay      512
-#   Teensy++ halfKay    1024
-#   Atmel DFU loader    4096
-#   LUFA bootloader     4096
-#   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   change yes to no to disable
 #

keyboards/ai03/orbit/rules.mk

@@ -1,69 +1,16 @@
-SRC += split_util.c \
-	   split_flags.c \
-	   serial.c \
-	   transport.c \
-	   matrix.c
-
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = atmel-dfu
 
-
-# If you don't know the bootloader type, then you can specify the
-# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
-#   Teensy halfKay      512
-#   Teensy++ halfKay    1024
-#   Atmel DFU loader    4096
-#   LUFA bootloader     4096
-#   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   change yes to no to disable
 #
@@ -88,4 +35,8 @@ USE_I2C = no                # I2C for split communication
 CUSTOM_MATRIX = yes			# For providing custom matrix.c (in this case, override regular matrix.c with split matrix.c)
 # SPLIT_KEYBOARD = yes		# Split keyboard flag disabled as manual edits had to be done to the split common files
 
-
+SRC += split_util.c \
+	   split_flags.c \
+	   serial.c \
+	   transport.c \
+	   matrix.c

keyboards/ai03/quasar/rules.mk

@@ -1,63 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = atmel-dfu
 
-
-# If you don't know the bootloader type, then you can specify the
-# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
-#   Teensy halfKay      512
-#   Teensy++ halfKay    1024
-#   Atmel DFU loader    4096
-#   LUFA bootloader     4096
-#   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   change yes to no to disable
 #

keyboards/ai03/soyuz/rules.mk

@@ -1,63 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = atmel-dfu
 
-
-# If you don't know the bootloader type, then you can specify the
-# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
-#   Teensy halfKay      512
-#   Teensy++ halfKay    1024
-#   Atmel DFU loader    4096
-#   LUFA bootloader     4096
-#   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   change yes to no to disable
 #

keyboards/akb/eb46/rules.mk

@@ -1,63 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = atmel-dfu
 
-
-# If you don't know the bootloader type, then you can specify the
-# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
-#   Teensy halfKay      512
-#   Teensy++ halfKay    1024
-#   Atmel DFU loader    4096
-#   LUFA bootloader     4096
-#   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   change yes to no to disable
 #

keyboards/akb/raine/rules.mk

@@ -1,63 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = atmel-dfu
 
-
-# If you don't know the bootloader type, then you can specify the
-# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
-#   Teensy halfKay      512
-#   Teensy++ halfKay    1024
-#   Atmel DFU loader    4096
-#   LUFA bootloader     4096
-#   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   change yes to no to disable
 #

keyboards/al1/rules.mk

@@ -1,51 +1,15 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
+BOOTLOADER = atmel-dfu
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
-#   Teensy halfKay   512
-#   Teensy++ halfKay 1024
-#   Atmel DFU loader 4096
-#   LUFA bootloader  4096
-#   USBaspLoader     2048
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
 
 # Build Options
 #   change yes to no to disable

keyboards/alf/dc60/rules.mk

@@ -1,51 +1,15 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
+BOOTLOADER = atmel-dfu
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
-#   Teensy halfKay   512
-#   Teensy++ halfKay 1024
-#   Atmel DFU loader 4096
-#   LUFA bootloader  4096
-#   USBaspLoader     2048
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
 
 # Build Options
 #   change yes to no to disable

keyboards/alf/x11/rules.mk

@@ -1,63 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = atmel-dfu
 
-
-# If you don't know the bootloader type, then you can specify the
-# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
-#   Teensy halfKay      512
-#   Teensy++ halfKay    1024
-#   Atmel DFU loader    4096
-#   LUFA bootloader     4096
-#   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   change yes to no to disable
 #

keyboards/alf/x2/rules.mk

@@ -1,45 +1,15 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
+BOOTLOADER = atmel-dfu
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
 
 # Build Options
 #   comment out to disable the options.

keyboards/alpha/keymaps/hvp/keymap.c

@@ -0,0 +1,51 @@
+#include QMK_KEYBOARD_H
+
+enum layer_names {
+    HOME,
+    MODS,
+    MODS2,
+    OTHER,
+};
+
+enum custom_keycodes {
+	MACRO1 = SAFE_RANGE
+};
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+	if (record->event.pressed) {
+		switch (keycode) {
+			case MACRO1:
+				SEND_STRING("I'm so sorry... -PyroL");
+				return false;
+		}
+	}
+	return true;
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+	[HOME] = LAYOUT(
+		KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, MT(MOD_LCTL,KC_P),
+		KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, MT(MOD_LSFT,KC_ENT),
+		KC_Z, KC_X, KC_C, LT(MODS2,KC_V), LT(MODS, KC_SPC), LT(OTHER,KC_B), KC_N, KC_M),
+
+	[MODS] = LAYOUT(
+		KC_TAB, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_BSPC,
+		KC_LSFT, KC_ESC, _______, KC_SCLN, KC_QUOT, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, _______,
+		KC_LCTL, KC_LGUI, KC_LALT, _______, _______, KC_COMM, KC_DOT, KC_SLSH),
+
+	[MODS2] = LAYOUT(
+		KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0,
+		KC_LSFT, KC_ESC, _______, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS, KC_GRV, _______,
+		RGB_VAI, RGB_VAD, RGB_HUI, _______, _______, KC_MPLY, KC_VOLD, KC_VOLU),
+
+	[OTHER] = LAYOUT(
+		KC_ESC, RESET, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_DEL,
+		KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, _______,
+		KC_F10, KC_F11, KC_F12, _______, _______, KC_NO, KC_NO, KC_NO),
+};
+
+void matrix_init_user(void) {
+}
+
+void matrix_scan_user(void) {
+}

keyboards/alpha/rules.mk

@@ -1,46 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
 BOOTLOADER = caterina
 
-
 # Build Options
 #   comment out to disable the options.
 #

keyboards/alu84/rules.mk

@@ -1,45 +1,15 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
+BOOTLOADER = atmel-dfu
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
 
 # Build Options
 #   comment out to disable the options.

keyboards/amj40/rules.mk

@@ -1,51 +1,15 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
+BOOTLOADER = atmel-dfu
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
-#   Teensy halfKay   512
-#   Teensy++ halfKay 1024
-#   Atmel DFU loader 4096
-#   LUFA bootloader  4096
-#   USBaspLoader     2048
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
 
 # Build Options
 #   comment out to disable the options.

keyboards/amj60/rules.mk

@@ -1,51 +1,15 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
+BOOTLOADER = atmel-dfu
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
-#   Teensy halfKay   512
-#   Teensy++ halfKay 1024
-#   Atmel DFU loader 4096
-#   LUFA bootloader  4096
-#   USBaspLoader     2048
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
 
 # Build Options
 #   comment out to disable the options.

keyboards/amj96/rules.mk

@@ -1,51 +1,15 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
+BOOTLOADER = atmel-dfu
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
-#   Teensy halfKay   512
-#   Teensy++ halfKay 1024
-#   Atmel DFU loader 4096
-#   LUFA bootloader  4096
-#   USBaspLoader     2048
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
 
 # Build Options
 #   change yes to no to disable

keyboards/amjkeyboard/amj66/rules.mk

@@ -1,53 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = atmel-dfu
 
-
 # Build Options
 #   change yes to no to disable
 #

keyboards/amjpad/rules.mk

@@ -1,51 +1,15 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
+BOOTLOADER = atmel-dfu
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
-#   Teensy halfKay   512
-#   Teensy++ halfKay 1024
-#   Atmel DFU loader 4096
-#   LUFA bootloader  4096
-#   USBaspLoader     2048
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
 
 # Build Options
 #   comment out to disable the options.

keyboards/angel17/rules.mk

@@ -1,27 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = caterina
 
-
-# If you don't know the bootloader type, then you can specify the
-# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
-#   Teensy halfKay      512
-#   Teensy++ halfKay    1024
-#   Atmel DFU loader    4096
-#   LUFA bootloader     4096
-#   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   change yes to no to disable
 #

keyboards/angel64/rules.mk

@@ -1,63 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = atmel-dfu
 
-
-# If you don't know the bootloader type, then you can specify the
-# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
-#   Teensy halfKay      512
-#   Teensy++ halfKay    1024
-#   Atmel DFU loader    4096
-#   LUFA bootloader     4096
-#   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   change yes to no to disable
 #

keyboards/at101_blackheart/rules.mk

@@ -1,49 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
 # Bootloader selection
+#   Teensy       halfkay
+#   Pro Micro    caterina
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = halfkay
 
-# Boot Section Size in *bytes*
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   comment out to disable the options.
 #

keyboards/atomic/rules.mk

@@ -1,49 +1,15 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
+BOOTLOADER = atmel-dfu
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
-#   Teensy halfKay   512
-#   Teensy++ halfKay 1024
-#   Atmel DFU loader 4096
-#   LUFA bootloader  4096
-#   USBaspLoader     2048
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
 
 # Build Options
 #   change to "no" to disable the options, or define them in the Makefile in 

keyboards/atreus/astar/rules.mk

@@ -1,58 +1,12 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = caterina
-
-
-# If you don't know the bootloader type, then you can specify the
-# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
-#   Teensy halfKay      512
-#   Teensy++ halfKay    1024
-#   Atmel DFU loader    4096
-#   LUFA bootloader     4096
-#   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096

keyboards/atreus/teensy2/rules.mk

@@ -1,58 +1,12 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = halfkay
-
-
-# If you don't know the bootloader type, then you can specify the
-# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
-#   Teensy halfKay      512
-#   Teensy++ halfKay    1024
-#   Atmel DFU loader    4096
-#   LUFA bootloader     4096
-#   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096

keyboards/atreus62/rules.mk

@@ -1,47 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Bootloader
-#     This definition is optional, and if your keyboard supports multiple bootloaders of
-#     different sizes, comment this out, and the correct address will be loaded 
-#     automatically (+60). See bootloader.mk for all options.
 BOOTLOADER = caterina
 
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
 # Build Options
 #   change to "no" to disable the options, or define them in the Makefile in
 #   the appropriate keymap folder that will get included automatically

keyboards/baguette/rules.mk

@@ -1,63 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = atmel-dfu
 
-
-# If you don't know the bootloader type, then you can specify the
-# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
-#   Teensy halfKay      512
-#   Teensy++ halfKay    1024
-#   Atmel DFU loader    4096
-#   LUFA bootloader     4096
-#   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   change yes to no to disable
 #

keyboards/bantam44/rules.mk

@@ -1,51 +1,15 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
+BOOTLOADER = halfkay
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
-#   Teensy halfKay   512
-#   Teensy++ halfKay 1024
-#   Atmel DFU loader 4096
-#   LUFA bootloader  4096
-#   USBaspLoader     2048
-OPT_DEFS += -DBOOTLOADER_SIZE=512
-
 
 # Build Options
 #   comment out to disable the options.

keyboards/bigswitch/rules.mk

@@ -1,49 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Bootloader
 BOOTLOADER = caterina
 
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   comment out to disable the options.
 #

keyboards/blockey/rules.mk

@@ -1,51 +1,15 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
+BOOTLOADER = caterina
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
-#   Teensy halfKay   512
-#   Teensy++ halfKay 1024
-#   Atmel DFU loader 4096
-#   LUFA bootloader  4096
-#   USBaspLoader     2048
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
 
 # Build Options
 #   change yes to no to disable

keyboards/bm16a/rules.mk

@@ -1,63 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = atmel-dfu
 
-
-# If you don't know the bootloader type, then you can specify the
-# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
-#   Teensy halfKay      512
-#   Teensy++ halfKay    1024
-#   Atmel DFU loader    4096
-#   LUFA bootloader     4096
-#   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   change yes to no to disable
 #

keyboards/bm16s/rules.mk

@@ -1,60 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = atmel-dfu
 
-
-# If you don't know the bootloader type, then you can specify the
-# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
-#   Teensy halfKay      512
-#   Teensy++ halfKay    1024
-#   Atmel DFU loader    4096
-#   LUFA bootloader     4096
-#   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
 # Build Options
 #   comment out to disable the options.
 #

keyboards/boardwalk/rules.mk

@@ -1,48 +1,14 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-# Boot Section Size in *bytes*
-#   Teensy halfKay   512
-#   Teensy++ halfKay 1024
-#   Atmel DFU loader 4096
-#   LUFA bootloader  4096
-#   USBaspLoader     2048
 BOOTLOADER = atmel-dfu
 
 # QMK Build Options

keyboards/bpiphany/sixshooter/rules.mk

@@ -1,49 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-# Bootloader
-#     This definition is optional, and if your keyboard supports multiple bootloaders of
-#     different sizes, comment this out, and the correct address will be loaded
-#     automatically (+60). See bootloader.mk for all options.
 BOOTLOADER = halfkay
 
-
 # Build Options
 #   change yes to no to disable
 #

keyboards/bthlabs/geekpad/rules.mk

@@ -1,63 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = caterina
 
-
-# If you don't know the bootloader type, then you can specify the
-# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
-#   Teensy halfKay      512
-#   Teensy++ halfKay    1024
-#   Atmel DFU loader    4096
-#   LUFA bootloader     4096
-#   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   change yes to no to disable
 #

keyboards/business_card/alpha/rules.mk

@@ -1,63 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = atmel-dfu
 
-
-# If you don't know the bootloader type, then you can specify the
-# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
-#   Teensy halfKay      512
-#   Teensy++ halfKay    1024
-#   Atmel DFU loader    4096
-#   LUFA bootloader     4096
-#   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   change yes to no to disable
 #

keyboards/business_card/beta/rules.mk

@@ -1,63 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = atmel-dfu
 
-
-# If you don't know the bootloader type, then you can specify the
-# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
-#   Teensy halfKay      512
-#   Teensy++ halfKay    1024
-#   Atmel DFU loader    4096
-#   LUFA bootloader     4096
-#   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   change yes to no to disable
 #

keyboards/business_card/rules.mk

@@ -1,63 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = atmel-dfu
 
-
-# If you don't know the bootloader type, then you can specify the
-# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
-#   Teensy halfKay      512
-#   Teensy++ halfKay    1024
-#   Atmel DFU loader    4096
-#   LUFA bootloader     4096
-#   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   change yes to no to disable
 #

keyboards/butterstick/rules.mk

@@ -1,15 +1,16 @@
 # MCU name
 MCU = atmega32u4
-F_CPU = 16000000
-ARCH = AVR8
-F_USB = $(F_CPU)
-
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT -DONLYQWERTY -DDEBUG_MATRIX
-SRC += sten.c
-EXTRAFLAGS += -flto
-
 
+# Bootloader selection
+#   Teensy       halfkay
+#   Pro Micro    caterina
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = atmel-dfu
+
 MOUSEKEY_ENABLE 	= yes		# Mouse keys(+4700)
 EXTRAKEY_ENABLE 	= yes       # Audio control and System control(+450)
 CONSOLE_ENABLE 		= yes       # Console for debug(+400)
@@ -17,3 +18,6 @@ COMMAND_ENABLE 		= no		# Commands for debug and configuration
 NKRO_ENABLE 		= yes       # USB Nkey Rollover
 STENO_ENABLE		= yes 		# Needed for chording
 
+OPT_DEFS += -DONLYQWERTY -DDEBUG_MATRIX
+SRC += sten.c
+EXTRAFLAGS += -flto

keyboards/c39/rules.mk

@@ -1,50 +1,15 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
+BOOTLOADER = caterina
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
-#   Teensy halfKay   512
-#   Teensy++ halfKay 1024
-#   Atmel DFU loader 4096
-#   LUFA bootloader  4096
-#   USBaspLoader     2048
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
 
 # Build Options
 #   change yes to no to disable

keyboards/cannonkeys/satisfaction75/satisfaction_oled.c

@@ -91,8 +91,8 @@ void draw_default(){
   if (hour == 0){
     hour = 12;
   }
-  char hour_str[2] = "";
+  char hour_str[3] = "";
-  char min_str[2] = "";
+  char min_str[3] = "";
 
   sprintf(hour_str, "%02d", hour);
   sprintf(min_str, "%02d", minute);
@@ -199,11 +199,11 @@ void draw_clock(){
   if (hour == 0){
     hour = 12;
   }
-  char hour_str[2] = "";
+  char hour_str[3] = "";
-  char min_str[2] = "";
+  char min_str[3] = "";
-  char year_str[4] = "";
+  char year_str[5] = "";
-  char month_str[2] = "";
+  char month_str[3] = "";
-  char day_str[2] = "";
+  char day_str[3] = "";
 
   sprintf(hour_str, "%02d", hour);
   sprintf(min_str, "%02d", minute);

keyboards/catch22/rules.mk

@@ -1,49 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Bootloader
 BOOTLOADER = caterina
 
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
-#OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   comment out to disable the options.
 #
@@ -57,4 +24,3 @@ NKRO_ENABLE  = no		# USB Nkey Rollover - if this doesn't work, see here: https:/
 BACKLIGHT_ENABLE  = no  # Custom backlighting code is used, so this should not be enabled
 AUDIO_ENABLE  = no # This can be enabled if a speaker is connected to the expansion port. Not compatible with RGBLIGHT below
 RGBLIGHT_ENABLE  = yes # This can be enabled if a ws2812 strip is connected to the expansion port.
-

keyboards/chimera_ergo/rules.mk

@@ -1,66 +1,16 @@
-
-OPT_DEFS += -DCHIMERA_ERGO_PROMICRO
-CHIMERA_ERGO_UPLOAD_COMMAND = while [ ! -r $(USB) ]; do sleep 1; done; \
-                         avrdude -p $(MCU) -c avr109 -U flash:w:$(TARGET).hex -P $(USB)
-
-# # project specific files
-SRC = matrix.c
-
-
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Bootloader
-#     This definition is optional, and if your keyboard supports multiple bootloaders of
-#     different sizes, comment this out, and the correct address will be loaded 
-#     automatically (+60). See bootloader.mk for all options.
 BOOTLOADER = caterina
 
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-# Boot Section Size in *bytes*
-#   Teensy halfKay   512
-#   Teensy++ halfKay 1024
-#   Atmel DFU loader 4096
-#   LUFA bootloader  4096
-#   USBaspLoader     2048
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   comment out to disable the options.
 #
@@ -78,4 +28,12 @@ NKRO_ENABLE = yes		# USB Nkey Rollover - not yet supported in LUFA
 UNICODE_ENABLE = YES 		# Unicode
 # BLUETOOTH_ENABLE = yes # Enable Bluetooth with the Adafruit EZ-Key HID
 
+
+OPT_DEFS += -DCHIMERA_ERGO_PROMICRO
+CHIMERA_ERGO_UPLOAD_COMMAND = while [ ! -r $(USB) ]; do sleep 1; done; \
+                         avrdude -p $(MCU) -c avr109 -U flash:w:$(TARGET).hex -P $(USB)
+
+# # project specific files
+SRC = matrix.c
+
 USB = /dev/ttyACM0

keyboards/chimera_ls/rules.mk

@@ -1,66 +1,16 @@
-
-OPT_DEFS += -DCHIMERA_LS_PROMICRO
-CHIMERA_LS_UPLOAD_COMMAND = while [ ! -r $(USB) ]; do sleep 1; done; \
-                         avrdude -p $(MCU) -c avr109 -U flash:w:$(TARGET).hex -P $(USB)
-
-# # project specific files
-SRC = matrix.c
-
-
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Bootloader
-#     This definition is optional, and if your keyboard supports multiple bootloaders of
-#     different sizes, comment this out, and the correct address will be loaded
-#     automatically (+60). See bootloader.mk for all options.
 BOOTLOADER = caterina
 
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-# Boot Section Size in *bytes*
-#   Teensy halfKay   512
-#   Teensy++ halfKay 1024
-#   Atmel DFU loader 4096
-#   LUFA bootloader  4096
-#   USBaspLoader     2048
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   comment out to disable the options.
 #
@@ -80,4 +30,11 @@ UNICODE_ENABLE = YES 		# Unicode
 
 USB = /dev/ttyACM0
 
+OPT_DEFS += -DCHIMERA_LS_PROMICRO
+CHIMERA_LS_UPLOAD_COMMAND = while [ ! -r $(USB) ]; do sleep 1; done; \
+                         avrdude -p $(MCU) -c avr109 -U flash:w:$(TARGET).hex -P $(USB)
+
+# project specific files
+SRC = matrix.c
+
 LAYOUTS = ortho_4x12

keyboards/chimera_ortho/rules.mk

@@ -1,57 +1,16 @@
-
-OPT_DEFS += -DCHIMERA_ORTHO_PROMICRO
-CHIMERA_ORTHO_UPLOAD_COMMAND = while [ ! -r $(USB) ]; do sleep 1; done; \
-                         avrdude -p $(MCU) -c avr109 -U flash:w:$(TARGET).hex -P $(USB)
-
-# # project specific files
-SRC = matrix.c
-
-
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Bootloader
-#     This definition is optional, and if your keyboard supports multiple bootloaders of
-#     different sizes, comment this out, and the correct address will be loaded 
-#     automatically (+60). See bootloader.mk for all options.
 BOOTLOADER = caterina
 
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
 # Build Options
 #   comment out to disable the options.
 #
@@ -70,3 +29,10 @@ UNICODE_ENABLE = YES 		# Unicode
 # BLUETOOTH_ENABLE = yes # Enable Bluetooth with the Adafruit EZ-Key HID
 
 USB = /dev/ttyACM0
+
+OPT_DEFS += -DCHIMERA_ORTHO_PROMICRO
+CHIMERA_ORTHO_UPLOAD_COMMAND = while [ ! -r $(USB) ]; do sleep 1; done; \
+                         avrdude -p $(MCU) -c avr109 -U flash:w:$(TARGET).hex -P $(USB)
+
+# project specific files
+SRC = matrix.c

keyboards/choco60/rules.mk

@@ -1,63 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = caterina
 
-
-# If you don't know the bootloader type, then you can specify the
-# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
-#   Teensy halfKay      512
-#   Teensy++ halfKay    1024
-#   Atmel DFU loader    4096
-#   LUFA bootloader     4096
-#   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   change yes to no to disable
 #

keyboards/christmas_tree/rules.mk

@@ -1,49 +1,15 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
+BOOTLOADER = caterina
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
-#   Teensy halfKay   512
-#   Teensy++ halfKay 1024
-#   Atmel DFU loader 4096
-#   LUFA bootloader  4096
-#   USBaspLoader     2048
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
 
 # Build Options
 #   change to "no" to disable the options, or define them in the Makefile in 

keyboards/ckeys/handwire_101/rules.mk

@@ -1,52 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
-#   Teensy halfKay   512
-#   Teensy++ halfKay 1024
-#   Atmel DFU loader 4096
-#   LUFA bootloader  4096
-#   USBaspLoader     2048
 BOOTLOADER = caterina
 
-
 # Build Options
 #   change yes to no to disable
 #

keyboards/ckeys/nakey/rules.mk

@@ -1,51 +1,15 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
+BOOTLOADER = halfkay
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
-#   Teensy halfKay   512
-#   Teensy++ halfKay 1024
-#   Atmel DFU loader 4096
-#   LUFA bootloader  4096
-#   USBaspLoader     2048
-OPT_DEFS += -DBOOTLOADER_SIZE=512
-
 
 # Build Options
 #   change yes to no to disable

keyboards/ckeys/obelus/rules.mk

@@ -1,51 +1,15 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
+BOOTLOADER = atmel-dfu
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
-#   Teensy halfKay   512
-#   Teensy++ halfKay 1024
-#   Atmel DFU loader 4096
-#   LUFA bootloader  4096
-#   USBaspLoader     2048
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
 
 # Build Options
 #   change yes to no to disable

keyboards/claw44/rules.mk

@@ -1,54 +1,16 @@
-SRC += i2c.c
-SRC += serial.c
-SRC += ssd1306.c
-
-# if firmware size over limit, try this option
-# CFLAGS += -flto
-
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Bootloader
-#     This definition is optional, and if your keyboard supports multiple bootloaders of
-#     different sizes, comment this out, and the correct address will be loaded
-#     automatically (+60). See bootloader.mk for all options.
 BOOTLOADER = caterina
 
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
 # Build Options
 #   change to "no" to disable the options, or define them in the Makefile in
 #   the appropriate keymap folder that will get included automatically
@@ -69,5 +31,11 @@ RGBLIGHT_ENABLE = no       # Enable WS2812 RGB underlight.
 SLEEP_LED_ENABLE = no    # Breathing sleep LED during USB suspend
 
 CUSTOM_MATRIX = yes
+SRC += i2c.c
+SRC += serial.c
+SRC += ssd1306.c
+
+# if firmware size over limit, try this option
+# CFLAGS += -flto
 
 DEFAULT_FOLDER = claw44/rev1

keyboards/clueboard/17/rules.mk

@@ -1,51 +1,15 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
+BOOTLOADER = atmel-dfu
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
-#   Teensy halfKay   512
-#   Teensy++ halfKay 1024
-#   Atmel DFU loader 4096
-#   LUFA bootloader  4096
-#   USBaspLoader     2048
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
 
 # Build Options
 BOOTMAGIC_ENABLE = no	      # Virtual DIP switch configuration(+1000)

keyboards/clueboard/66/rev1/rules.mk

@@ -1,10 +1,15 @@
-LAYOUTS = 66_ansi 66_iso
+# MCU name
 MCU = atmega32u4
-F_CPU = 16000000
+
-ARCH = AVR8
+# Bootloader selection
-F_USB = $(F_CPU)
+#   Teensy       halfkay
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+#   Pro Micro    caterina
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
+BOOTLOADER = atmel-dfu
 
 # Build Options
 #   comment out to disable the options.
@@ -21,3 +26,5 @@ RGBLIGHT_ENABLE = no    # Enable keyboard underlight functionality
 MIDI_ENABLE = no 		    # MIDI controls
 UNICODE_ENABLE = no 		# Unicode
 BLUETOOTH_ENABLE = no   # Enable Bluetooth with the Adafruit EZ-Key HID
+
+LAYOUTS = 66_ansi 66_iso

keyboards/clueboard/66/rev2/rules.mk

@@ -1,11 +1,15 @@
-LAYOUTS = 66_ansi 66_iso
+# MCU name
 MCU = atmega32u4
-F_CPU = 16000000
-ARCH = AVR8
-F_USB = $(F_CPU)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
 
+# Bootloader selection
+#   Teensy       halfkay
+#   Pro Micro    caterina
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
+BOOTLOADER = atmel-dfu
 
 # Build Options
 BACKLIGHT_ENABLE = yes
@@ -20,3 +24,5 @@ RGBLIGHT_ENABLE = yes   # Enable keyboard underlight functionality
 MIDI_ENABLE = no 		    # MIDI controls
 UNICODE_ENABLE = no 		# Unicode
 BLUETOOTH_ENABLE = no   # Enable Bluetooth with the Adafruit EZ-Key HID
+
+LAYOUTS = 66_ansi 66_iso

keyboards/clueboard/66/rev3/rules.mk

@@ -1,10 +1,15 @@
-LAYOUTS = 66_ansi 66_iso
+# MCU name
 MCU = atmega32u4
-F_CPU = 16000000
+
-ARCH = AVR8
+# Bootloader selection
-F_USB = $(F_CPU)
+#   Teensy       halfkay
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+#   Pro Micro    caterina
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
+BOOTLOADER = atmel-dfu
 
 # Build Options
 #   comment out to disable the options.
@@ -21,3 +26,5 @@ RGBLIGHT_ENABLE = yes   # Enable keyboard underlight functionality
 MIDI_ENABLE = no 		    # MIDI controls
 UNICODE_ENABLE = no 		# Unicode
 BLUETOOTH_ENABLE = no   # Enable Bluetooth with the Adafruit EZ-Key HID
+
+LAYOUTS = 66_ansi 66_iso

keyboards/clueboard/66_hotswap/prototype/rules.mk

@@ -1,11 +1,15 @@
-EXTRAFLAGS += -flto
+# MCU name
-LAYOUTS = 66_ansi
 MCU = atmega32u4
-F_CPU = 16000000
+
-ARCH = AVR8
+# Bootloader selection
-F_USB = $(F_CPU)
+#   Teensy       halfkay
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+#   Pro Micro    caterina
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
+BOOTLOADER = atmel-dfu
 
 # Build Options
 #   comment out to disable the options.
@@ -22,3 +26,6 @@ RGBLIGHT_ENABLE = yes
 MIDI_ENABLE = no
 UNICODE_ENABLE = no
 BLUETOOTH_ENABLE = no
+
+EXTRAFLAGS += -flto
+LAYOUTS = 66_ansi

keyboards/clueboard/card/rules.mk

@@ -1,9 +1,15 @@
+# MCU name
 MCU = atmega32u4
-F_CPU = 16000000
+
-ARCH = AVR8
+# Bootloader selection
-F_USB = $(F_CPU)
+#   Teensy       halfkay
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+#   Pro Micro    caterina
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
+BOOTLOADER = atmel-dfu
 
 
 # Build Options

keyboards/cocoa40/keymaps/default/rules.mk

@@ -1 +0,0 @@
-

keyboards/cocoa40/rules.mk

@@ -1,63 +1,16 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
-#     This will define a symbol, F_CPU, in all source code files equal to the
-#     processor frequency in Hz. You can then use this symbol in your source code to
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
-#     automatically to create a 32-bit value in your source code.
-#
-#     This will be an integer division of F_USB below, as it is sourced by
-#     F_USB after it has run through any CPU prescalers. Note that this value
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
-#   atmega32a    bootloadHID
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
 BOOTLOADER = caterina
 
-
-# If you don't know the bootloader type, then you can specify the
-# Boot Section Size in *bytes* by uncommenting out the OPT_DEFS line
-#   Teensy halfKay      512
-#   Teensy++ halfKay    1024
-#   Atmel DFU loader    4096
-#   LUFA bootloader     4096
-#   USBaspLoader        2048
-# OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
-
 # Build Options
 #   change yes to no to disable
 #

keyboards/comet46/rules.mk

@@ -1,50 +1,15 @@
-# # project specific files
-SRC += matrix.c \
-       i2c.c \
-       ssd1306.c 
-       
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
+BOOTLOADER = caterina
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Bootloader
-#     This definition is optional, and if your keyboard supports multiple bootloaders of
-#     different sizes, comment this out, and the correct address will be loaded 
-#     automatically (+60). See bootloader.mk for all options.
-# BOOTLOADER = caterina
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
 
 # Build Options
 #   comment out to disable the options.
@@ -64,3 +29,7 @@ UNICODE_ENABLE = YES 		# Unicode
 # BLUETOOTH_ENABLE = yes # Enable Bluetooth with the Adafruit EZ-Key HID
 
 USB = /dev/ttyACM0
+# project specific files
+SRC += matrix.c \
+       i2c.c \
+       ssd1306.c

keyboards/contra/rules.mk

@@ -1,45 +1,15 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
+BOOTLOADER = caterina
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-
-# Boot Section Size in *bytes*
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
-
 
 # Build Options
 #   change yes to no to disable

keyboards/converter/adb_usb/rules.mk

@@ -1,59 +1,16 @@
 # MCU name
-# atmega32u4  Teensy2.0
-# atemga32u4  TMK Converter rev.1
-# atemga32u2  TMK Converter rev.2
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-#
-F_CPU = 16000000
-# F_CPU = 8000000
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-# Bootloader
-#     This definition is optional, and if your keyboard supports multiple bootloaders of
-#     different sizes, comment this out, and the correct address will be loaded
-#     automatically (+60). See bootloader.mk for all options.
 BOOTLOADER = caterina
 
-# Boot Section Size in *bytes*
-#   Teensy halfKay   512
-#   Teensy++ halfKay 1024
-#   Atmel DFU loader 4096  for TMK Converter rev.1/rev.2
-#   LUFA bootloader  4096
-#   USBaspLoader     2048
-
 # Build Options
 #   comment out to disable the options.
 #

keyboards/converter/hp_46010a/rules.mk

@@ -1,45 +1,14 @@
 # MCU name
 MCU = atmega32u4
 
-# Processor frequency.
+# Bootloader selection
-#     This will define a symbol, F_CPU, in all source code files equal to the
+#   Teensy       halfkay
-#     processor frequency in Hz. You can then use this symbol in your source code to
+#   Pro Micro    caterina
-#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#   Atmel DFU    atmel-dfu
-#     automatically to create a 32-bit value in your source code.
+#   LUFA DFU     lufa-dfu
-#
+#   QMK DFU      qmk-dfu
-#     This will be an integer division of F_USB below, as it is sourced by
+#   ATmega32A    bootloadHID
-#     F_USB after it has run through any CPU prescalers. Note that this value
+#   ATmega328P   USBasp
-#     does not *change* the processor frequency - it should merely be updated to
-#     reflect the processor speed set externally so that the code can use accurate
-#     software delays.
-F_CPU = 16000000
-
-#
-# LUFA specific
-#
-# Target architecture (see library "Board Types" documentation).
-ARCH = AVR8
-
-# Input clock frequency.
-#     This will define a symbol, F_USB, in all source code files equal to the
-#     input clock frequency (before any prescaling is performed) in Hz. This value may
-#     differ from F_CPU if prescaling is used on the latter, and is required as the
-#     raw input clock is fed directly to the PLL sections of the AVR for high speed
-#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
-#     at the end, this will be done automatically to create a 32-bit value in your
-#     source code.
-#
-#     If no clock division is performed on the input clock inside the AVR (via the
-#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB = $(F_CPU)
-
-# Interrupt driven control endpoint task(+60)
-OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
-
-# Bootloader
-#     This definition is optional, and if your keyboard supports multiple bootloaders of
-#     different sizes, comment this out, and the correct address will be loaded
-#     automatically (+60). See bootloader.mk for all options.
 BOOTLOADER = halfkay
 
 # Build Options