docs/fr-fr/newbs_flashing.md

   1 # Flasher votre clavier
   2
   3 Maintenant que vous avez compilé un firmware custom, vous allez vouloir le flasher dans votre clavier.
   4
   5 ## Flasher votre clavier avec QMK Toolbox
   6
   7 La manière la plus simple de flasher votre clavier est avec [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases).
   8
   9 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).
  10
  11 ### Charger le fichier dans QMK Toolbox
  12
  13 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`.
  14
  15 ?> 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.
  16
  17 ?> Windows:
  18
  19     start .
  20
  21 ?> macOS:
  22
  23     open .
  24
  25 Le fichier firmware suit toujours ce format de nommage:
  26
  27     <keyboard_name>_<keymap_name>.{bin,hex}
  28
  29 Par exemple, le `plank/rev5` avec une keymap `default` aura ce nom de fichier:
  30
  31     planck_rev5_default.hex
  32
  33 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é.
  34
  35 ### Mettez votre clavier en mode DFU (Bootloader)
  36
  37 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.
  38
  39 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:
  40
  41 * Enfoncez les deux touches shift et appuyez sur `Pause`
  42 * Enfoncez les deux touches shift et appuyez sur `B`
  43 * 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.
  44 * Appuyez la touche physique `RESET` en bas du PCB
  45 * Trouvez les pins sur le PCB marquées `BOOT0` ou `RESET`, court circuitez ces pins en branchant votre PCB
  46
  47 Lorsque vous aurez réussi, vous verrez le message suivant dans QMK Toolbox:
  48
  49 ```
  50 *** Clueboard - Clueboard 66% HotSwap disconnected -- 0xC1ED:0x2390
  51 *** DFU device connected
  52 ```
  53
  54 ### Flasher votre clavier
  55
  56 Appuyez sur le boutton `Flash` dans QMK Toolbox. Vous verrez un résultat similaire à ce qui suit:
  57
  58 ```
  59 *** Clueboard - Clueboard 66% HotSwap disconnected -- 0xC1ED:0x2390
  60 *** DFU device connected
  61 *** Attempting to flash, please don't remove device
  62 >>> dfu-programmer atmega32u4 erase --force
  63     Erasing flash...  Success
  64     Checking memory from 0x0 to 0x6FFF...  Empty.
  65 >>> dfu-programmer atmega32u4 flash /Users/skully/qmk_firmware/clueboard_66_hotswap_gen1_skully.hex
  66     Checking memory from 0x0 to 0x55FF...  Empty.
  67     0%                            100%  Programming 0x5600 bytes...
  68     [>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]  Success
  69     0%                            100%  Reading 0x7000 bytes...
  70     [>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]  Success
  71     Validating...  Success
  72     0x5600 bytes written into 0x7000 bytes memory (76.79%).
  73 >>> dfu-programmer atmega32u4 reset
  74
  75 *** DFU device disconnected
  76 *** Clueboard - Clueboard 66% HotSwap connected -- 0xC1ED:0x2390
  77 ```
  78
  79 ## Flashez votre clavier à l'aide de la ligne de commande
  80
  81 C'est désormais relativement simple. Lorsque vous êtes prêt à compiler et à flasher votre firmware, ouvrez la fenêtre de votre terminal et exécutez la commande de build :
  82
  83     make <my_keyboard>:<my_keymap>:flash
  84
  85 Par exemple, si votre keymap s'appelle "xyverz" et que vous fabriquez une keymap pour un clavier `planck` de version `rev5` vous devrez utiliser cette commande:
  86
  87     make planck/rev5:xyverz:flash
  88
  89 La commande va vérifier la configuration du clavier, puis tentera de le flasher en fonction du bootloader (chargeur d’amorçage) spécifié. Cela signifie que vous n'avez pas besoin de savoir quel bootloader votre clavier utilise. Exécutez simplement la commande et laissez-le faire le gros du travail.
  90
  91 Cependant, tout dépend du bootloader qui est installé sur le clavier. Si cette information n’est pas configurée ou si vous tentez de flasher un clavier qui ne permet pas d’être flashé alors vous obtiendrez cette erreur :
  92
  93     WARNING: This board's bootloader is not specified or is not supported by the ":flash" target at this time.
  94
  95 Dans ce cas, vous devrez choisir le bootloader.
  96
  97 Il y a cinq bootloaders principaux. Les Pro-Micro et les clones utilisent Caterina, les Teensy utilisent Halfkay, les claviers AVR d’OLKB utilisent QMK-DFU, certains controleurs atmega32u4 utilisent DFU et la plupart des controlleurs ARM utilisent ARM DFU.
  98
  99 Vous pouvez trouver plus d'information à propos des bootloaders sur la page [Instructions de flash et information sur le Bootloader](flashing.md).
 100
 101 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.
 102
 103 ### DFU
 104
 105 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:
 106
 107     make <my_keyboard>:<my_keymap>:dfu
 108
 109 Par exemple, si vous keymap s'appelle "xyverz" et vous compilez une keymap pour une plank rev5, vous utiliserez cette commande:
 110
 111     make planck/rev5:xyverz:dfu
 112
 113 Une fois la compilation terminée, le résultat devrait être le suivant:
 114
 115 ```
 116 Linking: .build/planck_rev5_xyverz.elf                                                              [OK]
 117 Creating load file for flashing: .build/planck_rev5_xyverz.hex                                      [OK]
 118 Copying planck_rev5_xyverz.hex to qmk_firmware folder                                               [OK]
 119 Checking file size of planck_rev5_xyverz.hex
 120  * File size is fine - 18574/28672
 121  ```
 122
 123 Une fois arrivé à ce stade, le script de compilation va chercher 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.
 124
 125     dfu-programmer: no device present.
 126     Error: Bootloader not found. Trying again in 5s.
 127
 128 Une fois terminé, vous devrez mettre à zéro le contrôleur. Vous allez voir un résultat similaire à ceci:
 129
 130 ```
 131 *** Attempting to flash, please don't remove device
 132 >>> dfu-programmer atmega32u4 erase --force
 133     Erasing flash...  Success
 134     Checking memory from 0x0 to 0x6FFF...  Empty.
 135 >>> dfu-programmer atmega32u4 flash /Users/skully/qmk_firmware/clueboard_66_hotswap_gen1_skully.hex
 136     Checking memory from 0x0 to 0x55FF...  Empty.
 137     0%                            100%  Programming 0x5600 bytes...
 138     [>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]  Success
 139     0%                            100%  Reading 0x7000 bytes...
 140     [>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]  Success
 141     Validating...  Success
 142     0x5600 bytes written into 0x7000 bytes memory (76.79%).
 143 >>> dfu-programmer atmega32u4 reset
 144 ```
 145
 146 ?> Si vous avez des soucis concernant ceci - par exemple `dfu-programmer: no device present` - merci de regarder [Foires Aux Questions de Compilation](faq_build.md).
 147
 148 #### Commandes DFU
 149
 150 Il y  aun certain nombre de commandes du DFU que vous pouvez utiliser pour flasher un firmware sur un device DFU:
 151
 152 * `: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.
 153 * `:dfu-ee` - Ceci flash un fichier `eep` à la place du standard hex, peu commun.
 154 * `: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._
 155 * `: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._
 156
 157 ### Caterina
 158
 159 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:
 160
 161     make <my_keyboard>:<my_keymap>:avrdude
 162
 163 Par exemple, si votre keymap se nomme "xyverz" et que vous compilez une keymap pour un Lets Split rev2, vous utiliserez la commande suivante:
 164
 165     make lets_split/rev2:xyverz:avrdude
 166
 167 Une fois le firmware compilé, vous aurez le résultat suivant:
 168
 169 ```
 170 Linking: .build/lets_split_rev2_xyverz.elf                                                            [OK]
 171 Creating load file for flashing: .build/lets_split_rev2_xyverz.hex                                    [OK]
 172 Checking file size of lets_split_rev2_xyverz.hex                                                      [OK]
 173  * File size is fine - 27938/28672
 174 Detecting USB port, reset your controller now..............
 175 ```
 176
 177 Une fois ceci fait, réinitialisez votre board et le script va détecter et flasher le firmware. La sortie devrait ressembler à quelque chose comme ça:
 178
 179 ```
 180 Detected controller on USB port at /dev/ttyS15
 181
 182 Connecting to programmer: .
 183 Found programmer: Id = "CATERIN"; type = S
 184     Software Version = 1.0; No Hardware Version given.
 185 Programmer supports auto addr increment.
 186 Programmer supports buffered memory access with buffersize=128 bytes.
 187
 188 Programmer supports the following devices:
 189     Device code: 0x44
 190
 191 avrdude.exe: AVR device initialized and ready to accept instructions
 192
 193 Reading | ################################################## | 100% 0.00s
 194
 195 avrdude.exe: Device signature = 0x1e9587 (probably m32u4)
 196 avrdude.exe: NOTE: "flash" memory has been specified, an erase cycle will be performed
 197              To disable this feature, specify the -D option.
 198 avrdude.exe: erasing chip
 199 avrdude.exe: reading input file "./.build/lets_split_rev2_xyverz.hex"
 200 avrdude.exe: input file ./.build/lets_split_rev2_xyverz.hex auto detected as Intel Hex
 201 avrdude.exe: writing flash (27938 bytes):
 202
 203 Writing | ################################################## | 100% 2.40s
 204
 205 avrdude.exe: 27938 bytes of flash written
 206 avrdude.exe: verifying flash memory against ./.build/lets_split_rev2_xyverz.hex:
 207 avrdude.exe: load data flash data from input file ./.build/lets_split_rev2_xyverz.hex:
 208 avrdude.exe: input file ./.build/lets_split_rev2_xyverz.hex auto detected as Intel Hex
 209 avrdude.exe: input file ./.build/lets_split_rev2_xyverz.hex contains 27938 bytes
 210 avrdude.exe: reading on-chip flash data:
 211
 212 Reading | ################################################## | 100% 0.43s
 213
 214 avrdude.exe: verifying ...
 215 avrdude.exe: 27938 bytes of flash verified
 216
 217 avrdude.exe: safemode: Fuses OK (E:CB, H:D8, L:FF)
 218
 219 avrdude.exe done.  Thank you.
 220 ```
 221
 222 Si vous avez un souci, essayez de faire ceci:
 223
 224     sudo make <my_keyboard>:<my_keymap>:avrdude
 225
 226 #### Commandes Caterina
 227
 228 Il existe un certain nombre de commandes DFU que vous pouvez utiliser pour mettre à jour le firmware sur un périphérique DFU:
 229
 230 * `: avrdude` - Il s’agit de l’option normale. Elle attend qu’un appareil Caterina soit disponible, puis tente de flasher le firmware. Il attendra de détecter un autre port COM, puis il flashera à nouveau.
 231 * `: avrdude-loop` - Cela fonctionne de la même manière que `: avrdude`, mais une fois que chaque périphérique est flashé, il tentera de flasher à nouveau. Cela peut être utile pour flasher plusieurs claviers à la suite. _Cela implique de sortir manuellement de la boucle en appuyant sur Ctrl + C, Cmd + C ou un raccourci équivalent selon votre OS_
 232 * `: avrdude-split-left` - Cela fonctionne de la même manière que la fonction (`: avrdude`). Toutefois, cela permet aussi de flasher le coté gauche de l'EEPROM des claviers splittés / divisés. C'est donc la méthode recommandée pour les claviers splittés avec Pro Micro.
 233 * `: avrdude-split-right` - Cela fonctionne de la même manière que la fonction (`: avrdude`). Toutefois, cela permet aussi de flasher le coté droite de l'EEPROM des claviers splittés / divisés. C'est donc la méthode recommandée pour les claviers splittés avec Pro Micro.
 234
 235 ### HalfKay
 236
 237 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:
 238
 239     make <my_keyboard>:<my_keymap>:teensy
 240
 241 Par exemple, si vous keymap s'appelle "xyverz" et vous compilez une keymap pour un Ergodox ou un Ergodox EZ, vous utiliserez cette commande:
 242
 243     make ergodox_ez:xyverz:teensy
 244
 245 Une fois la compilation du firmware terminée, votre sortie devrait ressembler à ça:
 246
 247 ```
 248 Linking: .build/ergodox_ez_xyverz.elf                                                               [OK]
 249 Creating load file for flashing: .build/ergodox_ez_xyverz.hex                                       [OK]
 250 Checking file size of ergodox_ez_xyverz.hex                                                         [OK]
 251  * File size is fine - 25584/32256
 252  Teensy Loader, Command Line, Version 2.1
 253 Read "./.build/ergodox_ez_xyverz.hex": 25584 bytes, 79.3% usage
 254 Waiting for Teensy device...
 255  (hint: press the reset button)
 256  ```
 257
 258 Une fois terminé, réinitialisez votre board. Une fois fait, vous verrez une sortie comme ça:
 259
 260  ```
 261  Found HalfKay Bootloader
 262 Read "./.build/ergodox_ez_xyverz.hex": 28532 bytes, 88.5% usage
 263 Programming............................................................................................................................................................................
 264 ...................................................
 265 Booting
 266 ```
 267
 268 ### STM32 (ARM)
 269
 270 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:
 271
 272     make <my_keyboard>:<my_keymap>:dfu-util
 273
 274 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):
 275
 276     make planck/rev6:xyverz:dfu-util
 277
 278 Une fois le firmware compilé, il va afficher quelque chose comme ça:
 279
 280 ```
 281 Linking: .build/planck_rev6_xyverz.elf                                                             [OK]
 282 Creating binary load file for flashing: .build/planck_rev6_xyverz.bin                               [OK]
 283 Creating load file for flashing: .build/planck_rev6_xyverz.hex                                     [OK]
 284
 285 Size after:
 286    text    data     bss     dec     hex filename
 287       0   41820       0   41820    a35c .build/planck_rev6_xyverz.hex
 288
 289 Copying planck_rev6_xyverz.bin to qmk_firmware folder                                              [OK]
 290 dfu-util 0.9
 291
 292 Copyright 2005-2009 Weston Schmidt, Harald Welte and OpenMoko Inc.
 293 Copyright 2010-2016 Tormod Volden and Stefan Schmidt
 294 This program is Free Software and has ABSOLUTELY NO WARRANTY
 295 Please report bugs to http://sourceforge.net/p/dfu-util/tickets/
 296
 297 Invalid DFU suffix signature
 298 A valid DFU suffix will be required in a future dfu-util release!!!
 299 Opening DFU capable USB device...
 300 ID 0483:df11
 301 Run-time device DFU version 011a
 302 Claiming USB DFU Interface...
 303 Setting Alternate Setting #0 ...
 304 Determining device status: state = dfuERROR, status = 10
 305 dfuERROR, clearing status
 306 Determining device status: state = dfuIDLE, status = 0
 307 dfuIDLE, continuing
 308 DFU mode device DFU version 011a
 309 Device returned transfer size 2048
 310 DfuSe interface name: "Internal Flash  "
 311 Downloading to address = 0x08000000, size = 41824
 312 Download        [=========================] 100%        41824 bytes
 313 Download done.
 314 File downloaded successfully
 315 Transitioning to dfuMANIFEST state
 316 ```
 317
 318 #### Commandes STM32
 319
 320 Il y  aun certain nombre de commandes du DFU que vous pouvez utiliser pour flasher un firmware sur un device STM32:
 321
 322 * `:dfu-util` - C'est l'option standard pour flasher un appareil STM32. Elle attendra qu'un bootloader STM32 soit présent et tentera de l’utiliser.
 323 * `: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.
 324 * `: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.
 325 * `: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.
 326
 327 ### BootloadHID
 328
 329 Pour les claviers basés sur Bootmapper Client(BMC)/bootloadHID/ATmega32A, si vous êtes prêts à compiler et flasher le firmware, ouvrez votre fenêtre de terminal et lancez la commande suivante :
 330
 331     make <my_keyboard>:<my_keymap>:bootloaderHID
 332
 333 Par exemple, si votre keymap s'appelle "xyverz" et que vous compilez une keymap pour un jj40, utilisez cette commande:
 334
 335     make jj40:xyverz:bootloaderHID
 336
 337 Une fois le firmware compilé, vous aurez cette sortie:
 338
 339 ```
 340 Linking: .build/jj40_default.elf                                                                   [OK]
 341 Creating load file for flashing: .build/jj40_default.hex                                           [OK]
 342 Copying jj40_default.hex to qmk_firmware folder                                                    [OK]
 343 Checking file size of jj40_default.hex                                                             [OK]
 344  * The firmware size is fine - 21920/28672 (6752 bytes free)
 345 ```
 346
 347 A ce stade, le script de build va chercher le bootloader DFU toutes les 5 secondes. Il répétera l ’affichage de ce message jusqu'à ce que l’appareil soit trouvé ou que vous annuliez l'opération```
 348
 349 ```
 350 Error opening HIDBoot device: The specified device was not found
 351 Trying again in 5s.
 352 ```
 353
 354 Une fois ce résultat obtenu, réinitialisez le contrôleur. Le résultat suivant devrait s’afficher :
 355
 356 ```
 357 Page size   = 128 (0x80)
 358 Device size = 32768 (0x8000); 30720 bytes remaining
 359 Uploading 22016 (0x5600) bytes starting at 0 (0x0)
 360 0x05580 ... 0x05600
 361 ```
 362
 363 ## Faites l'essai!
 364
 365 Bravo! Votre firmware customisé a été programmé sur votre clavier!
 366
 367 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.