[Docs] Start of German translation of documentation (#6909)
* Initial commit * Fix links so that they point to the german translation * minor changes to the wording of some sentences * correctly capitalize second person pronouns * Fix links so that they point to the german translation * minor changes to the wording of some sentences * correctly capitalize second person pronouns * Translate newbs_learn_more_resources.md * Clear up some phrases * Add newbs_building_firmware.md, fix spelling * Add newbs_building_firmware.md, fix spelling * Update docs/de/_summary.md Danke * Update docs/de/README.md * Update docs/de/_summary.md Ich wollte es kuerzer halten damit die Navigationsleiste nicht zu breit wird, aber das ist halt die deutsche Sprache :) * Update docs/de/newbs.md * Update docs/de/newbs_getting_started.md * Update docs/de/newbs_getting_started.md * Update docs/de/newbs_getting_started.md * Update docs/de/newbs_getting_started.md * Update docs/de/newbs_getting_started.md * Update docs/de/newbs.md * Update docs/de/newbs_learn_more_resources.md * Update docs/de/newbs_getting_started.md * Update docs/de/newbs_getting_started.md * Update docs/de/newbs.md * Update docs/de/newbs.md * Update docs/de/newbs.md * Update docs/de/README.md * Update docs/de/README.md * Update docs/de/README.md * Update docs/de/README.md * Update docs/de/newbs_getting_started.md * Update docs/de/newbs_getting_started.md * Update docs/de/newbs_building_firmware.md * Update docs/de/newbs_building_firmware.md * Update docs/de/newbs_building_firmware.md * Update docs/de/newbs_building_firmware.md * Update docs/de/newbs_learn_more_resources.md * Update docs/de/newbs_building_firmware.md * Update docs/de/newbs_building_firmware.md * Update docs/de/newbs_learn_more_resources.md * Update docs/de/newbs_building_firmware.md * Update docs/de/newbs_building_firmware.md * Update docs/de/newbs_learn_more_resources.md * Update docs/de/newbs_building_firmware.md * Update docs/de/newbs_getting_started.md * Update docs/de/newbs_getting_started.md * Update docs/de/newbs_building_firmware.md * Update docs/de/newbs_building_firmware.md * Update docs/de/newbs_building_firmware.md * Update docs/de/newbs_building_firmware.md * Apply suggestions from code review * Add translation of newbs_flashing.md * Apply suggestions from code review Danke * Add translation of Zadig-guide * Translate newbs_testing_debugging.md to german Co-Authored-By: Max Rumpf <max.rumpf1998@gmail.com> Co-Authored-By: geisterfurz007 <geisterfurz007@users.noreply.github.com>master
kuchosauronad0
James Young
parent
3b9a139c07
commit
b90edb75a3
|
|
@ -0,0 +1,33 @@
|
|||
# Quantum Mechanical Keyboard Firmware
|
||||
|
||||
[](https://github.com/qmk/qmk_firmware/tags)
|
||||
[](https://travis-ci.org/qmk/qmk_firmware)
|
||||
[](https://discord.gg/Uq7gcHh)
|
||||
[](https://docs.qmk.fm)
|
||||
[](https://github.com/qmk/qmk_firmware/pulse/monthly)
|
||||
[](https://github.com/qmk/qmk_firmware/)
|
||||
|
||||
## Was ist QMK Firmware?
|
||||
|
||||
QMK (*Quantum Mechanical Keyboard*) ist eine Open-Source-Community, welche die QMK-Firmware, die QMK-Toolbox, [qmk.fm](https://qmk.fm) und diese Dokumententation betreut. QMK-Firmware ist eine Weiterentwicklung der [tmk\_keyboard](http://github.com/tmk/tmk_keyboard)-Tastatur-Firmware mit vielen nützlichen Zusatzfunktionen für Atmel AVR-Prozessoren. Ursprünglich wurde sie für Produkte von [OLKB](http://olkb.com), das [ErgoDox EZ](http://www.ergodox-ez.com) und das [Clueboard](http://clueboard.co/) entwickelt. Im Laufe der Zeit wurde sie mit Hilfe von [ChibiOS](http://chibios.org) auch für die ARM-Architektur angepasst. Außerdem ist es inzwischen möglich, auch handverdrahtete Tastaturen und selbst geätzte PCBs mit QMK zu verwenden.
|
||||
|
||||
## Bezugsquelle für QMK
|
||||
|
||||
Wenn Du vorhast, deine Tastatur, Tastaturbelegung oder Features zu QMK beizusteuern, geht das am einfachsten, indem Du das [Repository auf Github](https://github.com/qmk/qmk_firmware#fork-destination-box) forkst, die Änderungen in deinem lokalen Repo vornimmst und anschließend einen [Pull Request](https://github.com/qmk/qmk_firmware/pulls) einreichst.
|
||||
|
||||
Ansonsten kannst Du es als [zip](https://github.com/qmk/qmk_firmware/zipball/master) oder [tar](https://github.com/qmk/qmk_firmware/tarball/master) herunterladen, oder es direkt via git klonen (`git clone git@github.com:qmk/qmk_firmware.git` bzw. `git clone https://github.com/qmk/qmk_firmware.git`).
|
||||
|
||||
|
||||
## Anleitung fürs Kompilieren
|
||||
|
||||
Bevor Du in der Lage bist, die Firmware zu kompilieren, musst Du eine [Entwicklungsumgebung](de/getting_started_build_tools.md) für AVR und/oder ARM aufsetzen. Danach kannst Du mit dem `make` Befehl eine Keymap für deine Tastatur erzeugen. Die Notation dafür ist:
|
||||
|
||||
make planck/rev4:default
|
||||
|
||||
Dies generiert die Revision `rev4` für eine Tastatur vom Type `planck` mit der `default` Tastaturbelegung. Nicht alle Tastaturen haben Revisionen (auch bekannt als Subprojekt oder Unterordner) weswegen dies auch ausgelassen werden kann:
|
||||
|
||||
make preonic:default
|
||||
|
||||
## Möglichkeiten der Anpassung
|
||||
|
||||
QMK hat viele [Features](de/features.md), die es zu entdecken gibt. In der [Dokumentation](https://docs.qmk.fmk) kannst Du Dir einen Überblick verschaffen. Die meisten Features basieren darauf, die [Tastaturbelegung](de/keymap.md) anzupassen und das Verhalten der [Keycodes](de/keycodes.md) zu verändern.
|
||||
|
|
@ -0,0 +1,121 @@
|
|||
* [Anleitung für Anfänger](de/newbs.md)
|
||||
* [Erste Schritte](de/newbs_getting_started.md)
|
||||
* [Die erste Firmware](de/newbs_building_firmware.md)
|
||||
* [Firmware flashen](de/newbs_flashing.md)
|
||||
* [Testen und Debuggen](de/newbs_testing_debugging.md)
|
||||
* [Git Tips und Tricks](de/newbs_best_practices.md)
|
||||
* [Hilfreiche Ressourcen](de/newbs_learn_more_resources.md)
|
||||
|
||||
* [QMK Basics](de/README.md)
|
||||
* [QMK Einführung](de/getting_started_introduction.md)
|
||||
* [QMK CLI](de/cli.md)
|
||||
* [QMK CLI Konfiguration](de/cli_configuration.md)
|
||||
* [Zu QMK beitragen](de/contributing.md)
|
||||
* [Anleitung für Github](de/getting_started_github.md)
|
||||
* [Nach Hilfe fragen](de/getting_started_getting_help.md)
|
||||
|
||||
* [Breaking Changes](de/breaking_changes.md)
|
||||
* [2019 Aug 30](de/ChangeLog/20190830.md)
|
||||
|
||||
* [FAQ](de/faq.md)
|
||||
* [Häufige Fragen](de/faq_general.md)
|
||||
* [Build/Kompilieren](de/faq_build.md)
|
||||
* [Debugging/Troubleshooting](de/faq_debug.md)
|
||||
* [Keymap](de/faq_keymap.md)
|
||||
* [Treiber Installation mit Zadig](de/driver_installation_zadig.md)
|
||||
|
||||
* Detailierte Guides
|
||||
* [Build Tools installieren](de/getting_started_build_tools.md)
|
||||
* [Vagrant Guide](de/getting_started_vagrant.md)
|
||||
* [Build/Compile Anleitung](de/getting_started_make_guide.md)
|
||||
* [Firmware flashen](de/flashing.md)
|
||||
* [Funktionalität anpassen](de/custom_quantum_functions.md)
|
||||
* [Keymap Überblick](de/keymap.md)
|
||||
|
||||
* [Hardware](de/hardware.md)
|
||||
* [AVR Prozessoren](de/hardware_avr.md)
|
||||
* [Treiber](de/hardware_drivers.md)
|
||||
|
||||
* Referenz
|
||||
* [Tastatur Richtlinien](de/hardware_keyboard_guidelines.md)
|
||||
* [Konfigurations Optionen](de/config_options.md)
|
||||
* [Keycodes](de/keycodes.md)
|
||||
* [Coding Konventionen - C](de/coding_conventions_c.md)
|
||||
* [Coding Konventionen - Python](de/coding_conventions_python.md)
|
||||
* [Dokumentations Best Practices](de/documentation_best_practices.md)
|
||||
* [Dokumentations Templates](de/documentation_templates.md)
|
||||
* [Glossar](de/reference_glossary.md)
|
||||
* [Unit Testing](de/unit_testing.md)
|
||||
* [Nützliche Funktionen](de/ref_functions.md)
|
||||
* [Configurator Support](de/reference_configurator_support.md)
|
||||
* [info.json Format](de/reference_info_json.md)
|
||||
* [Python CLI Development](de/cli_development.md)
|
||||
|
||||
* [Features](de/features.md)
|
||||
* [Basic Keycodes](de/keycodes_basic.md)
|
||||
* [US ANSI Shifted Keys](de/keycodes_us_ansi_shifted.md)
|
||||
* [Quantum Keycodes](de/quantum_keycodes.md)
|
||||
* [Advanced Keycodes](de/feature_advanced_keycodes.md)
|
||||
* [Audio](de/feature_audio.md)
|
||||
* [Auto Shift](de/feature_auto_shift.md)
|
||||
* [Backlight](de/feature_backlight.md)
|
||||
* [Bluetooth](de/feature_bluetooth.md)
|
||||
* [Bootmagic](de/feature_bootmagic.md)
|
||||
* [Combos](de/feature_combo.md)
|
||||
* [Command](de/feature_command.md)
|
||||
* [Debounce API](de/feature_debounce_type.md)
|
||||
* [DIP Switch](de/feature_dip_switch.md)
|
||||
* [Dynamic Macros](de/feature_dynamic_macros.md)
|
||||
* [Encoders](de/feature_encoders.md)
|
||||
* [Grave Escape](de/feature_grave_esc.md)
|
||||
* [Haptic Feedback](de/feature_haptic_feedback.md)
|
||||
* [HD44780 LCD Controller](de/feature_hd44780.md)
|
||||
* [Key Lock](de/feature_key_lock.md)
|
||||
* [Layouts](de/feature_layouts.md)
|
||||
* [Leader Key](de/feature_leader_key.md)
|
||||
* [LED Matrix](de/feature_led_matrix.md)
|
||||
* [Macros](de/feature_macros.md)
|
||||
* [Mouse Keys](de/feature_mouse_keys.md)
|
||||
* [OLED Driver](de/feature_oled_driver.md)
|
||||
* [One Shot Keys](de/feature_advanced_keycodes.md#one-shot-keys)
|
||||
* [Pointing Device](de/feature_pointing_device.md)
|
||||
* [PS/2 Mouse](de/feature_ps2_mouse.md)
|
||||
* [RGB Lighting](de/feature_rgblight.md)
|
||||
* [RGB Matrix](de/feature_rgb_matrix.md)
|
||||
* [Space Cadet](de/feature_space_cadet.md)
|
||||
* [Split Keyboard](de/feature_split_keyboard.md)
|
||||
* [Stenography](de/feature_stenography.md)
|
||||
* [Swap Hands](de/feature_swap_hands.md)
|
||||
* [Tap Dance](de/feature_tap_dance.md)
|
||||
* [Terminal](de/feature_terminal.md)
|
||||
* [Thermal Printer](de/feature_thermal_printer.md)
|
||||
* [Unicode](de/feature_unicode.md)
|
||||
* [Userspace](de/feature_userspace.md)
|
||||
* [Velocikey](de/feature_velocikey.md)
|
||||
|
||||
* Für Maker und Modder
|
||||
* [Hand Wiring Guide](de/hand_wire.md)
|
||||
* [ISP Flashing Guide](de/isp_flashing_guide.md)
|
||||
* [ARM Debugging Guide](de/arm_debugging.md)
|
||||
* [I2C Driver](de/i2c_driver.md)
|
||||
* [GPIO Controls](de/internals_gpio_control.md)
|
||||
* [Proton C Conversion](de/proton_c_conversion.md)
|
||||
|
||||
* Für ein tieferes Verständnis
|
||||
* [Wie Tastaturen funktionieren](de/how_keyboards_work.md)
|
||||
* [QMK verstehen](de/understanding_qmk.md)
|
||||
|
||||
* Andere Themen
|
||||
* [Eclipse mit QMK](de/other_eclipse.md)
|
||||
* [VSCode mit QMK](de/other_vscode.md)
|
||||
* [Support](de/support.md)
|
||||
* [Übersetzungen](de/translating.md)
|
||||
|
||||
* QMK Internals (de/In Progress)
|
||||
* [Defines](de/internals_defines.md)
|
||||
* [Input Callback Reg](de/internals_input_callback_reg.md)
|
||||
* [Midi Device](de/internals_midi_device.md)
|
||||
* [Midi Device Setup Process](de/internals_midi_device_setup_process.md)
|
||||
* [Midi Util](de/internals_midi_util.md)
|
||||
* [Send Functions](de/internals_send_functions.md)
|
||||
* [Sysex Tools](de/internals_sysex_tools.md)
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
# Bootloader Treiber Installation mit Zadig
|
||||
|
||||
QMK erscheint für den Host als normales HID Eingabegerät und benötigt deshalb keine zusätzlichen Treiber. Der Bootloader, den Du für das Flashen der Firmware benötigst, jedoch meistens schon.
|
||||
|
||||
Hierzu gibt es zwei Ausnahmen: den Caterina Bootloader, meistens auf Pro Micros, sowie den HalfKay Bootloader auf PJRC Teensys. Diese erscheinen als serieller Port und als generisches HID Gerät und benötigen keine Treiber.
|
||||
|
||||
Wir empfehlen deshalb [Zadig](https://zadig.akeo.ie/). Wenn Du die Entwicklungsumgebung mit MSYS2 oder WSL installiert hast, wird dich dass `qmk_install.sh` Skript gefragt haben, ob es die Treiber für dich installieren sollte.
|
||||
|
||||
## Installation
|
||||
|
||||
Versetze deine Tastatur in den Bootloader-Modus, entweder durch Betätigung des physischen `RESET` Schalters - meist auf der Unterseite der Platine - oder durch das Auslösen des Key-Codes `RESET` bzw. `KC_RESET` (sollte in der zur Tastatur gehörigen `keycode.c` zu entnehmen sein). Sollte deine Tastatur weder noch besitzen, versuche es damit die `Escape`-Taste oder `Leertaste + B` zu halten während Du die Tastatur mit dem PC verbindest (Siehe auch [Bootmagic](de/feature_bootmagic.md) für weitere Details). Ein paar Tastaturen benutzen das [Command](de/feature_command.md)-Feature an Stelle von Bootmagic; in diesem Fall kannst du mit den Tastenkombinationen `linkes Shift + rechtes Shift + B` oder `linkes Shift + rechtes Shift + Escape` zu jeder Zeit in den Bootloader wechseln solange die Tastatur verbunden ist.
|
||||
|
||||
Eingie Tastaturen haben u.U. spezielle Anweisungen um in den Bootloader-Modus zu gelangen. Zum Beispiel kann die [Bootmagic-Lite](de/feature_bootmagic.md#bootmagic-lite)-Taste (default: Escape) auf eine andere Taste gemappt sein; oder die magische Kombination (default: linkes Shift+rechtes Shift) verwendet anstatt Shift die STRG-Tasten. Die zur Tastatur gehörige README sollte dir Aufschluss darüber geben wie der Bootloader-Modus ausgelöst werden kann wenn Du unsicher bist.
|
||||
|
||||
Um ein Gerät mit USBaspLoader in den Bootloader-Modus zu versetzen, halte `BOOT` gedrückt während Du den `RESET`-Knopf drückst.
|
||||
Alternativ, halte `BOOT` gedrückt während Du das USB-Kabel einsteckst.
|
||||
|
||||
Zadig sollte das Bootloader-Gerät automatisch erkennen. Manchmal musst Du zusätzlich noch **Options → List All Devices** auswählen.
|
||||
|
||||
- Tastaturen mit Atmel AVR MCUs sollten als `ATm32U4DFU` (oder ähnlich) angezeigt werden, mit der Vendor ID `03EB`.
|
||||
- USBasp werden als `USBasp` angezeigt, mit VID/PID `16C0:05DC`.
|
||||
- Tastaturen AVR controller und dem QMK-DFU Bootloader haben den namen `<Tastatur Name> Bootloader` und die VID `03EB`.
|
||||
- Die meisten ARM Tastaturen werden als `STM32 BOOTLOADER` angezeigt, mit VID/PID `0483:DF11`.
|
||||
|
||||
!> Sollte Zadig ein oder mehrere Geräte mit `HidUsb`-Treiber anzeigen, dann ist deine Tastatur wahrscheinlich nicht im Bootloader-Modus. Der Pfeil wird orange eingefärbt sein und Du wirst nach einer Bestätigung gefragt um Veränderungen am System vorzunehmen. In diesem Fall **fahre nicht fort**!
|
||||
|
||||
Wenn der Pfeil grün angezeigt wird, wähle den Treiber aus und klicke auf **Treiber installieren**. Der `libusb-win32`-Treiber sollte gewöhnlich für AVR verwendet werden und `WinUSB` für ARM. Sollte es danach noch nicht möglich sein die Tastatur zu flashen, versuche es mit einem anderen Treiber. Für USBaspLoader Geräte, die über die Befehlszeile mit MSYS2 geflasht werden, wird der `libusbk`-Treiber empfohlen. Ansonsten sollte `libusb-win32` funktionieren wenn die QMK Toolbox verwendet wird.
|
||||
|
||||
|
||||
|
||||
Entferne nun deine Tastatur und verbinde sie erneut um sicherzugehen dass der neue Treiber erfolgreich installiert wurde. Wenn Du QMK Toolbox benutzt, starte die Anwendung zur Sicherheit einmal neu, da Veränderungen am Treiber manchmal nicht richtig erkannt werden. Wenn dies immer noch nicht erfolgreich war hilft es an dieser Stelle manchmal ein Neustart des Computers.
|
||||
|
||||
## Wiederherstellung einer Installation für ein falsches Gerät
|
||||
|
||||
Wenn Du feststellst dass Du anschließend auf deiner Tastatur nicht mehr tippen kannst, ist etwas bei der Installation schief gelaufen. Ein häufiger Fehler ist es dass die Tastatur nicht im Bootloader-Modus war und stattdessen der Treiber für das HID-Gerät ersetzt wurde. Dies kannst Du einfach mit Zadig überprüfen, eine funktionierende Tastatur verwendet als Treiber `HidUsb` auf allen Interfaces .
|
||||
|
||||
|
||||
|
||||
Öffne den Geräte-Manager und suche nach einem Gerät das wie deine Tastatur aussieht.
|
||||
|
||||
|
||||
|
||||
Rechtsklick und **Gerät deinstallieren** anklicken. Bitte gehe sicher dass in diesem Schritt auch **Treibersoftware für dieses Gerät löschen** markiert ist.
|
||||
|
||||
|
||||
|
||||
Klick **Aktion → Suche nach veränderter Hardware**. Nun solltest Du wieder in der Lage sein normal zu tippen. Vergewissere dich mit Hilfe von Zadig dass die Tastatur nun `HidUsb` als Treiber verwendet. Wenn dies der Fall ist sollte wieder alles funktionieren.
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
# Anleitung für absolute Beginner
|
||||
QMK ist eine mächtige Open Source Firmware für mechanische Tastaturen. Mit QMK kannst Du deine Tastatur sowohl sehr einfach als auch sehr umfangreich anpassen. Menschen unterschiedlichen Wissensstandes - vom kompletten Anfänger bis zum erfahrenen Programmierer - haben ihre Tastaturen mit QMK erfolgreich auf ihre persönlichen Bedürfnisse angepasst. Diese Anleitung soll Dir unabhängig von deinen Vorkenntnissen dabei helfen dies ebenfalls zu bewältigen.
|
||||
|
||||
Bist Du unsicher ob deine Tastatur QMK unterstützt? Wenn es eine mechanische Tastatur ist, die Du selbst gebaut hast, stehen deine Chancen gut. Wir unterstützen eine [Vielzahl](https://qmk.fm/keyboards/) selbst gebauter Tastaturen, sodass selbst wenn deine jetzige Tastatur nicht unterstützt wird Du keine Probleme haben solltest eine für deine Anforderungen zu finden.
|
||||
|
||||
## Übersicht
|
||||
|
||||
Diese Anleitung ist in 7 Abschnitte unterteilt:
|
||||
|
||||
* [Die ersten Schritte](newbs_getting_started.md)
|
||||
* [Die erste Firmware auf der Kommandozeile erzeugen](newbs_building_firmware.md)
|
||||
* [Die erste Firmware mit der Online GUI erzeugen](newbs_building_firmware_configurator.md)
|
||||
* [Firmware flashen](newbs_flashing.md)
|
||||
* [Testen und Debuggen](newbs_testing_debugging.md)
|
||||
* [Git Leitfaden](newbs_best_practices.md)
|
||||
* [Weitere hilfreiche Ressourcen für Anfänger](newbs_learn_more_resources.md)
|
||||
|
||||
Diese Anleitung richtet sich an Personen, die vorher noch nie Software kompiliert haben. Die Entscheidungen und Empfehlungen basieren auf dieser Grundannahme. Es gibt unterschiedliche Herangehensweisen für viele der Prozeduren und wir unterstützen die meisten Alternativen. Wenn Du mal nicht weiter weißt oder Dir nicht sicher bist, wie Du an ein Problem herangehen sollst, kannst Du uns gerne [um Hilfe bitten](getting_started_getting_help.md).
|
||||
|
||||
## Weitere Ressourcen
|
||||
|
||||
* [Thomas Baart's QMK Basics Blog](https://thomasbaart.nl/category/mechanical-keyboards/firmware/qmk/qmk-basics/) – Ein äußerst hilfreicher Blog eines Community-Mitglieds, der einige Grundlagen der QMK-Firmware aus der Sicht des Benutzers erklärt (auf Englisch).
|
||||
|
|
@ -0,0 +1,78 @@
|
|||
# Eine eigene Firmware erstellen
|
||||
|
||||
Nachdem Du nun eine funktionierende Entwicklungsumgebung aufgesetzt hast, bist Du nun bereit, deine eigene Firmware zu erstellen. Dieses Sektion des Guides wird zwischen drei Programmen hin- und herwechseln: deinem Dateimanager, deinem Texteditor und der Befehlszeile. Lasse diese drei Fenster geöffnet, bis Du fertig und zufrieden mit deiner Tastatur-Firmware bist.
|
||||
|
||||
Solltest Du die Befehlszeile zwischenzeitlich geschlossen haben, vergiss nicht wieder in das richtige Verzeichnis zu navigieren, benutze dazu den Befehl `cd qmk_firmware`.
|
||||
|
||||
## Navigiere in deinen Keymap Ordner
|
||||
|
||||
Beginne damit, in das `keymaps` Verzeichnis für deine Tastatur zu navigieren.
|
||||
|
||||
Wenn Du macOS oder Windows benutzt, kannst Du einfach in das keymaps Verzeichnis wechseln.
|
||||
|
||||
?> macOS:<br>
|
||||
open keyboards/<keyboard_folder>/keymaps
|
||||
|
||||
?> Windows:<br>
|
||||
start .\\keyboards\\<keyboard_folder>\\keymaps
|
||||
|
||||
## Eine Kopie der `default` Tastaturbelegung erstellen
|
||||
|
||||
Wenn Du den `keymaps` Ordner geöffnet hast, solltest Du zuerst eine Kopie des `default` Verzeichnisses erstellen. Wir empfehlen dafür deinen GitHub Benutzernamen zu verweden, aber Du kannst auch jeden anderen Namen verwenden solange er nur aus Kleinbuchstaben, Zahlen und Unterstrichen besteht.
|
||||
|
||||
Um den Prozess zu automatisieren kannst Du dazu auch das Skript `new_keymap.sh` verwenden.
|
||||
|
||||
Navigiere dazu in das `qmk_firmware/util` Verzeichnis und gib folgenden Befehl ein:
|
||||
|
||||
```
|
||||
./new_keymap.sh <keyboard path> <username>
|
||||
```
|
||||
|
||||
Um zum Beispiel den Benutzernamen John für die Tastaturbelegung eines 1up60hse zu verwenden, würdest Du Folgendes eingeben:
|
||||
|
||||
```
|
||||
./new_keymap.sh 1upkeyboards/1up60hse john
|
||||
```
|
||||
|
||||
## Öffne `keymap.c` in deinem bevorzugtem Text Editor
|
||||
|
||||
Öffne deine `keymap.c`. In dieser Datei findest Du die Strukturen, die das Verhalten deiner Tastatur bestimmen. Oben in der `keymap.c` befinden sich Definitionen (defines) und Aufzählungen (enums), die die Tastaturbelegung leserlicher machen sollen. Weiter unten wirst Du eine Zeile finden, die wie folgt aussieht:
|
||||
|
||||
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
|
||||
|
||||
Diese Zeile markiert den Anfang der Liste der Ebenen (Layers). Darunter befinden sich Zeilen die entweder `LAYOUT` oder `KEYMAP` enthalten, das deutet auf den Start einer Ebene hin. Danach folgt eine Liste von Tasten, die dieser Ebene zugewiesen sind.
|
||||
|
||||
!> Beim Bearbeiten einer Tastaturbelegung solltest Du darauf achten, keine Kommata hinzuzufügen oder zu entfernen. Ansonsten kann dies dazu führen, dass deine Firmware nicht mehr kompiliert und es ist nicht immer einfach festzustellen, wo genau ein Komma zuviel oder zu wenig ist. Die letzte Zeile hat am Ende kein Komma, die Zeilen davor jedoch schon.
|
||||
|
||||
## Personalisiere die Tastaturbelegung nach deinen Wünschen
|
||||
|
||||
Wie Du diesen Schritt abschließt ist vollkommen Dir überlassen. Ändere die eine Sache die Dich stört oder verändere alles von Grund auf. Du kannst Ebenen entfernen die Du nicht brauchst oder Neue hinzufügen, bis zu 32 Stück. Die folgende Dokumentation verrät Dir was Du hier alles definieren kannst:
|
||||
|
||||
* [Keycodes](de/keycodes.md)
|
||||
* [Features](de/features.md)
|
||||
* [FAQ](de/faq.md)
|
||||
|
||||
?> Während Du langsam ein Gefühl dafür kriegst wie Keymaps funktionieren, solltest Du darauf achten nicht zuviel auf einmal zu verändern. Größere Änderungen machen es schwieriger, Probleme zu debuggen.
|
||||
|
||||
## Deine Firmware erzeugen
|
||||
|
||||
Wenn Du damit fertig bist, deine Tastaturbelegung anzupassen, musst Du noch die Firmware erzeugen. Öffne dazu wieder die Befehlszeile und führe folgenden Befehl aus:
|
||||
|
||||
make <my_keyboard>:<my_keymap>
|
||||
|
||||
Wenn deine Tastaturbelegung z.B. "xyverz" heißt und Du die Belegung für ein rev5 planck erzeugen möchtest, lautet der Befehl:
|
||||
|
||||
make planck/rev5:xyverz
|
||||
|
||||
Während des Kompiliervorgangs wird viel Text auf dem Bildschirm ausgegeben. Es sollte am Ende mit etwas enden das ungefähr so aussieht:
|
||||
|
||||
```
|
||||
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
|
||||
```
|
||||
|
||||
## Deine Firmware flashen
|
||||
Bitte fahre mit [Firmware flashen](de/newbs_flashing.md) fort, um zu erfahren, wie Du deine neue Firmware auf deine Tastatur flashen kannst.
|
||||
|
|
@ -0,0 +1,369 @@
|
|||
# Deine Tastatur flashen
|
||||
|
||||
Nachdem deine Firmware nun fertig ist musst Du Sie noch auf deine Tastatur flashen.
|
||||
|
||||
## Flash-Vorgang mit QMK Toolbox
|
||||
|
||||
Der einfachste Weg deine Tastatur zu flashen ist mit Hilfe der [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases)
|
||||
|
||||
Leider ist die QMK Toolbox derzeit nur für Windows und macOS verfügbar. Wenn Du Linux benutzt (oder es vorziehst die Firmware mit der Kommandozeile zu flashen) solltest Du die Methode benutzen die [hier](de/newbs_flashing.md#tastatur-mit-der-befehlszeile-flashen) beschrieben wird.
|
||||
|
||||
### Lade die Datei in QMK Toolbox
|
||||
|
||||
Beginne damit die Datei in der QMK Toolbox Anwendung zu laden. Versichere dich dass Du die Firmware-Datei im Finder oder Explorer findest. Deine Tastatur-Firmware sollte entweder vom Typ `.hex` oder `.bin` sein sein. QMK sollte die für deine Tastatur entsprechende Datei automatisch in das Root-Verzeichnis (normalerweise `qmk_firmware`) kopieren.
|
||||
|
||||
?> Wenn Du Windows oder macOS benutzt kannst Du mit folgenden Befehlen ganz einfach das aktuelle Firmware-Verzeichnis im Explorer oder Finder öffnen.
|
||||
|
||||
#### Windows:
|
||||
|
||||
``` start . ```
|
||||
|
||||
#### macOS:
|
||||
|
||||
``` open . ```
|
||||
|
||||
Die Firmware-Dateien folgen dabei immer folgendem Schema:
|
||||
|
||||
<meine_Tastatur>_<meine_Tastaturbelegung>.{bin,hex}
|
||||
|
||||
Zum Beispiel würde ein `planck/rev5` mit der `default` Tastaturbelegung folgenden Dateinamen haben:
|
||||
|
||||
planck_rev5_default.hex
|
||||
|
||||
Wenn Du die Firmware-Datei gefunden hast kannst Du sie in das "Local file" ("Lokale Datei") Feld in der QMK Toolbox ziehen, alternativ kannst Du auf "Öffnen" klicken und in das Verzeichnis navigieren indem sich die Firmware-Datei befindet.
|
||||
|
||||
### Die Tastatur in den DFU (Bootloader) Modus versetzen
|
||||
|
||||
Um deine angepasste Firmware auf deine Tastatur zu flashen musst Du diese erst in einen speziellen "flashing"-Modus versetzen. Während die Tastatur in diesem Modus ist kannst Du nicht auf ihr tippen oder sie wie gewohnt als Tastatur benutzen. Es ist wichtig dass der flashing-Prozesses nicht unterbrochen oder die Tastatur ausstöpselst wird, da der Vorgang ansonst wiederholt werden muss.
|
||||
|
||||
Verschiedene Tastaturen verwenden unterschiedliche Methoden um in den Bootloader-Modus zu gelangen. Wenn dein PCB im Moment QMK oder TMK verwendet und Du keine spezifischen Anweisungen erhalten hast probiere die folgenden Methoden in dieser Reihenfolge:
|
||||
|
||||
* Halte beide Shift-Tasten und drücke `Pause`
|
||||
* Halte beide Shift-Tasten und drücke `B`
|
||||
* Entferne deine Tastatur vom Computer, drücke gleichzeitig `Leertaste` und `B`, verbinde die Tastatur wieder mit dem Computer und warte eine Sekunde bevor Du die Tasten wieder loslässt.
|
||||
* Drücke den physischen `RESET`-Knopf auf der Unterseite des PCBs
|
||||
* Suche auf dem PCB den Pin mit dem Label `RESET`, verbinde diesen mit deinem GND-Pin
|
||||
* Suche auf dem PCB den Pin mit dem Label `BOOT0`, verbinde diesen mit GND und schließe die Tastatur wieder an den PC an TODO: DIS IS DANGEROUS!!
|
||||
|
||||
Wenn Du damit erfolgreich warst solltest Du in der QMK Toolbox eine Nachricht sehen die ungefähr so aussieht:
|
||||
|
||||
```
|
||||
*** Clueboard - Clueboard 66% HotSwap disconnected -- 0xC1ED:0x2390
|
||||
*** DFU device connected
|
||||
```
|
||||
|
||||
### Tastatur flashen
|
||||
|
||||
Klicke auf den `Flash`-Knopf in der QMK Toolbox. Die Ausgabe wird ungefähr so aussehen:
|
||||
|
||||
```
|
||||
*** 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 qmk_firmware/clueboard_66_hotswap_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
|
||||
```
|
||||
|
||||
## Tastatur mit der Befehlszeile flashen
|
||||
|
||||
Zunächst solltest Du versuchen herauszufinden welchen Bootlader deine Tastatur benutzt. Diese vier Bootloader sind am Weitesten verbreitet:
|
||||
|
||||
| MCU | Bootloader |
|
||||
| --- | --- |
|
||||
| Pro-Micro und Klone | CATERINA |
|
||||
| Teensy | Halfkay |
|
||||
| OLKB Boards | QMK-DFU |
|
||||
| sonstige atmega32u4 | DFU |
|
||||
|
||||
Auf der Seite [Flash Anleitung und Bootloader Informationen](de/flashing.md) kannst Du mehr über das Thema erfahren.
|
||||
|
||||
Wenn Du weißt welchen Bootloader deine Tastaur verwendet, kannst Du diese Information bei der Kompilation hinzufügen um den Flash-Vorgang mit dem `make`-Befehl zu automatisieren.
|
||||
```rules.mk
|
||||
...
|
||||
BOOTLOADER = caterina
|
||||
...
|
||||
```
|
||||
|
||||
### DFU
|
||||
|
||||
Wenn Du den DFU-Bootloader verwendest und Du bereit bist deine Firmware zu kompilieren und zu flashen, öffne ein Befehlszeile und führe folgenden Befehl aus:
|
||||
|
||||
make <meine_Tastatur>:<meine_Tastaturbelegung>:dfu
|
||||
|
||||
Wenn deine Tastaturbelegung z.B den Namen "xzverz" trägt und Du ein rev5 planck flashen möchtest sähe der Befehl wie folgt aus:
|
||||
|
||||
make planck/rev5:xyverz:dfu
|
||||
|
||||
|
||||
Nachdem der Vorgang abgeschlossen ist sollte die Ausgabe ungefähr so aussehen:
|
||||
|
||||
```
|
||||
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
|
||||
```
|
||||
|
||||
Wenn dieser Punkt erreicht ist wird das Build-Skript alle 5 Sekunden nach einem DFU Bootloader suchen. Dieser Vorgang wird wiederholt bis er erfolgreich ist oder abgebrochen wird.
|
||||
|
||||
dfu-programmer: no device present.
|
||||
Error: Bootloader not found. Trying again in 5s.
|
||||
|
||||
Wenn diese Nachricht erscheint konnte das Build-Skript den Controller nicht eigenständig in den DFU Modus versetzen (z.B. weil der Modus in rules.mk falsch gesetzt wurde oder ein Problem mit der Hardware besteht), wenn dies eintritt musst Du die oben beschrieben Schritte benutzen um den Controller in den DFU Modus zu versetzen. Danach sollte die Ausgabe ungefähr so aussehen:
|
||||
|
||||
```
|
||||
*** 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 qmk_firmware/clueboard_66_hotswap_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
|
||||
```
|
||||
|
||||
?> Wenn Du mit diesem Schritt Probleme hast (z.B. `dfu-programmer: no device present`) hilft dir hoffentlich der Abschnitt [Häufig gestellte Fragen (Build/Kompilieren)](de/faq_build.md).
|
||||
|
||||
#### DFU Befehle
|
||||
|
||||
Es gibt verschiedene DFU Befehle um die Firmware auf ein DFU Gerät zu flashen:
|
||||
|
||||
* `:dfu` - Dies ist die default Option. Es wird gecheckt ob ein DFU Gerät verfügbar ist, ist dies der Fall wird die Firmware geflasht. Dieser Check wird alle 5 Sekunden ausgeführt bis ein DFU Gerät erkannt wird.
|
||||
* `:dfu-ee` - Der Flash-Vorgang benutzt eine `.eep` Datei anstatt einer `.hex` Datei. Dies ist eher unüblich.
|
||||
* `:dfu-split-left` - Dies flasht die Firmware wie gewohnt (`:dfu`). Allerdings nur die "linke Seite" der EEPROM für geteilte Tastaturen. _Dies ist ideal für auf Elite C basierenden geteilten Tastaturen._
|
||||
* `:dfu-split-right` - Dies flasht die Firmware wie gewohnt (`:dfu`). Allerdings nur die "rechte Seite" der EEPROM für geteilte Tastaturen. _Dies ist ideal für auf Elite C basierenden geteilten Tastaturen._
|
||||
|
||||
|
||||
### Caterina
|
||||
Für Arduinos und andere ProMicro Klone (z.B. SparkFun ProMicro), wenn Du bereit bist zu kompilieren und die Tastatur zu flashen, öffne ein Befehlszeilen-Fenster und führe den Build-Befehl aus:
|
||||
|
||||
make <meine_Tastatur>:<meine_Tastaturbelegung>:avrdude
|
||||
|
||||
Wenn deine Tastaturbelegung zum Beispiel den Namen "xyverz" hat und Du eine Tastaturbelegung für ein "rev2 Lets Split" erzeugen möchtest, lautet der Befehl dafür:
|
||||
|
||||
make lets_split/rev2:xyverz:avrdude
|
||||
|
||||
Nachdem die Kompilation abgeschlossen ist sollte die Ausgabe ungefähr so aussehen:
|
||||
|
||||
```
|
||||
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..............
|
||||
```
|
||||
|
||||
Nun wird die Tastatur automatisch zurückgesetzt und das Skript wird die Firmware flashen sobald es den Bootloader erkennt. Die Ausgabe sollte ungefähr so aussehen:
|
||||
|
||||
```
|
||||
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.
|
||||
```
|
||||
Sollten dabei Probleme auftreten (z.B. "Zugriff verweigert" / "Permission denied") muss der Make-Befehl mit privilegierten Berechtigungen ausgeführt werden:
|
||||
|
||||
sudo make <meine_Tastatur>:<meine_Tastaturbelegung>:avrdude
|
||||
|
||||
Zusätzlich ist es möglich mehrere Tastaturen in einem Vorgang zu flashen:
|
||||
|
||||
make <keyboard>:<keymap>:avrdude-loop
|
||||
|
||||
Du kannst den Loop mit STRG + C unterbrechen sobald der Vorgang abgeschlossen ist. Die korrekte Tastenkombination kann abweichen und hängt vom Betriebssystem ab.
|
||||
|
||||
|
||||
### HalfKay
|
||||
|
||||
Für Tastaturen mit PJRC Controllern (Teensy's), wenn Du bereit bist zu kompilieren und die Tastatur zu flashen, öffne ein Befehlszeilen-Fenster und führe den Build-Befehl aus:
|
||||
|
||||
make <meine_Tastatur>:<meine_Tastaturbelegung>:teensy
|
||||
|
||||
Wenn deine Tastaturbelegung zum Beispiel den Namen "xyverz" hat und Du eine Tastaturbelegung für ein Ergodox oder Ergodox EZ erzeugen möchtest, lautet der Befehl dafür:
|
||||
|
||||
make ergodox_ez:xyverz:teensy
|
||||
|
||||
Nachdem die Kompilation abgeschlossen ist sollte die Ausgabe ungefähr so aussehen:
|
||||
|
||||
```
|
||||
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)
|
||||
```
|
||||
|
||||
An diesem Punkt solltest Du die Tastatur zurücksetzen um den Flash-Vorgang auszulösen. Wenn dies abgeschlossen ist sollte die Ausgabe ungefähr so aussehen:
|
||||
|
||||
```
|
||||
Found HalfKay Bootloader
|
||||
Read "./.build/ergodox_ez_xyverz.hex": 28532 bytes, 88.5% usage
|
||||
Programming.............................................................
|
||||
...................................................
|
||||
Booting
|
||||
```
|
||||
|
||||
### BootloadHID
|
||||
|
||||
Für auf Bootmapper Client(BMC)/bootloaderHID/ATmega32A basierende Tastaturen, wenn Du bereit bist zu kompilieren und die Tastatur zu flashen, öffne ein Befehlszeilen-Fenster und führe den Build-Befehl aus:
|
||||
|
||||
make <meine_Tastatur>:<meine_Tastaturbelegung>:bootloaderHID
|
||||
|
||||
Wenn deine Tastaturbelegung zum Beispiel den Namen "xyverz" hat und Du eine Tastaturbelegung für ein jj40 erzeugen möchtest, lautet der Befehl dafür:
|
||||
|
||||
make jj40:xyverz:bootloaderHID
|
||||
|
||||
Nachdem die Kompilation abgeschlossen ist sollte die Ausgabe ungefähr so aussehen:
|
||||
|
||||
```
|
||||
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)
|
||||
```
|
||||
|
||||
Wenn dieser Punkt erreicht ist wird das Build-Skript alle 5 Sekunden nach einem DFU Bootloader suchen. Dieser Vorgang wird wiederholt bis er erfolgreich ist oder abgebrochen wird.
|
||||
|
||||
```
|
||||
Error opening HIDBoot device: The specified device was not found
|
||||
Trying again in 5s.
|
||||
```
|
||||
|
||||
An diesem Punkt solltest Du die Tastatur zurücksetzen um den Flash-Vorgang auszulösen. Wenn dies abgeschlossen ist sollte die Ausgabe ungefähr so aussehen:
|
||||
|
||||
```
|
||||
Page size = 128 (0x80)
|
||||
Device size = 32768 (0x8000); 30720 bytes remaining
|
||||
Uploading 22016 (0x5600) bytes starting at 0 (0x0)
|
||||
0x05580 ... 0x05600
|
||||
```
|
||||
|
||||
### STM32 (ARM)
|
||||
|
||||
Für die meisten ARM Tastaturen (inkl. Proton C, Planck Rev 6 und Preonic Rev 3), wenn Du bereit bist zu kompilieren und die Tastatur zu flashen, öffne ein Befehlszeilen-Fenster und führe den Build-Befehl aus:
|
||||
|
||||
make <meine_Tastatur>:<meine_Tastaturbelegung>:dfu-util
|
||||
|
||||
Wenn deine Tastaturbelegung zum Beispiel den Namen "xyverz" hat und Du eine Tastaturbelegung für ein Planck Revision 6 erzeugen möchtest, benutze dafür den folgenden Befehl und reboote die Tastatur in den Bootloader (kurz bevor der Kompiliervorgang abgeschlossen ist):
|
||||
|
||||
make planck/rev6:xyverz:dfu-util
|
||||
|
||||
Nachdem der Kompiliervorgang abgeschlossen ist sollte die Ausgabe ungefähr so aussehen:
|
||||
|
||||
Für auf Bootmapper Client(BMC)/bootloaderHID/ATmega32A basierende Tastaturen, wenn Du bereit bist zu kompilieren und die Tastatur zu flashen, öffne ein Befehlszeilen-Fenster und führe den Build-Befehl aus:
|
||||
|
||||
make <meine_Tastatur>:<meine_Tastaturbelegung>:bootloaderHID
|
||||
|
||||
Wenn deine Tastaturbelegung zum Beispiel den Namen "xyverz" hat und Du eine Tastaturbelegung für ein jj40 erzeugen möchtest, lautet der Befehl dafür:
|
||||
```
|
||||
Linking: .build/planck_rev6_xyverz.elf [OK]
|
||||
Creating binary load file for flashing: .build/planck_rev6_xyverz.bin [OK]
|
||||
Creating load file for flashing: .build/planck_rev6_xyverz.hex [OK]
|
||||
|
||||
Size after:
|
||||
text data bss dec hex filename
|
||||
0 41820 0 41820 a35c .build/planck_rev6_xyverz.hex
|
||||
|
||||
Copying planck_rev6_xyverz.bin to qmk_firmware folder [OK]
|
||||
dfu-util 0.9
|
||||
|
||||
Copyright 2005-2009 Weston Schmidt, Harald Welte and OpenMoko Inc.
|
||||
Copyright 2010-2016 Tormod Volden and Stefan Schmidt
|
||||
This program is Free Software and has ABSOLUTELY NO WARRANTY
|
||||
Please report bugs to http://sourceforge.net/p/dfu-util/tickets/
|
||||
|
||||
Invalid DFU suffix signature
|
||||
A valid DFU suffix will be required in a future dfu-util release!!!
|
||||
Opening DFU capable USB device...
|
||||
ID 0483:df11
|
||||
Run-time device DFU version 011a
|
||||
Claiming USB DFU Interface...
|
||||
Setting Alternate Setting #0 ...
|
||||
Determining device status: state = dfuERROR, status = 10
|
||||
dfuERROR, clearing status
|
||||
Determining device status: state = dfuIDLE, status = 0
|
||||
dfuIDLE, continuing
|
||||
DFU mode device DFU version 011a
|
||||
Device returned transfer size 2048
|
||||
DfuSe interface name: "Internal Flash "
|
||||
Downloading to address = 0x08000000, size = 41824
|
||||
Download [=========================] 100% 41824 bytes
|
||||
Download done.
|
||||
File downloaded successfully
|
||||
Transitioning to dfuMANIFEST state
|
||||
```
|
||||
|
||||
#### STM32 Befehle
|
||||
|
||||
Für Tastaturen mit STM32 Controller sind die DFU Befehle wie folgt:
|
||||
|
||||
* `:dfu-util` - The default command for flashing to STM32 devices.
|
||||
* `:dfu-util` - Der Standard-Befehl für STM32 Geräte.
|
||||
* `:dfu-util-wait` - Funktioniert wie der Standard-Befehl, aber mit einem 10 Sekunden Timeout bevor erneut versucht wird die Firmware zu flashen. Mit dem Parameter `TIME_DELAY=20` auf der Befehlszeile kann der Timeout beeinflusst werden.
|
||||
* z.B.: `make <meine_Tastatur>:<meine_Tastaturbelegung>:dfu-util TIME_DELAY=5`
|
||||
* `:dfu-util-split-left` - Gleiche Funktionsweise wie `dfu-util`, jedoch wird zusätzlich das EEPROM Setting "linke Seite" für geteilte Tastaturen gesetzt.
|
||||
* `:dfu-util-split-right` - Gleiche Funktionsweise wie `dfu-util`, jedoch wird zusätzlich das EEPROM Setting "rechte Seite" für geteilte Tastaturen gesetzt.
|
||||
|
||||
## Probier's aus!
|
||||
|
||||
Herzlichen Glückwunsch! Deine individuell angepasst Firmware wurde auf deine Tastatur übertragen!
|
||||
|
||||
Probiere deine neue Tastatur aus und gehe sicher dass alles wie gewünscht funktioniert. Wir haben einen weiteren Artikel zum Thema [Testen und Debuggen](de/newbs_testing_debugging.md) verfasst der sich mit Problembeseitigung beschäftigt um den Beginnger-Guide abzuschließen.
|
||||
|
|
@ -0,0 +1,101 @@
|
|||
# Einleitung
|
||||
Genau wie in einem Computer befindet sich auch in einer Tastatur ein Prozessor.
|
||||
|
||||
Dieser Prozessor führt Software aus, die registriert wenn Tasten gedrückt bzw. wieder losgelassen werden und leitet die entsprechenden Signale an den Computer weiter.
|
||||
|
||||
QMK übernimmt die Rolle dieser Software und teilt dem Host-Computer den aktuellen Zustand der Tastatur mit. Wenn Du eine Tastaturbelegung definierst, ist dies äquivalent zu einem ausführbarem Programm, das auf deiner Tastatur läuft.
|
||||
|
||||
QMK möchte seine BenutzerInnen in die Lage versetzen, simple Aufgaben möglichst einfach zu gestalten und gleichzeitig komplexe Dinge zu ermöglichen, die mit normalen Tastaturen ohne zusätzliche Software undenkbar wären. Du musst nicht programmieren können, um abgefahrene Tastaturbelegungen zu gestalten - es reicht wenn Du eine Idee hast und ein paar einfache syntaktische Regeln verstehen kannst.
|
||||
|
||||
# Los geht's!
|
||||
Bevor Du damit loslegen kannst, deine Tastaturbelegung zu erstellen, musst Du ein wenig Software installieren und Dir eine Entwicklungsumgebung aufsetzen. Die gute Nachricht ist, dass das nur einmal erledigt werden muss, egal für wie viele verschiedene Tastaturen Du hinterher Firmware entwickeln willst.
|
||||
|
||||
Wenn Du es vorziehst mit einer grafischen Oberfläche zu entwickeln kannst Du auch dazu gerne direkt mit dem online [QMK Konfigurator](https://config.qmk.fm) loslegen. Siehe auch: [Firmware mit der Online GUI erzeugen](de/newbs_building_firmware_configurator.md)
|
||||
|
||||
## Software herunterladen
|
||||
|
||||
### Text Editor
|
||||
|
||||
Du wirst ein Programm benötigen, mit dem Du **plain text** (= reiner Text) Dateien bearbeiten und speichern kannst. Wenn Du Windows benutzt, reicht dafür schon das normale `Notepad` und für Linux z.B. `gedit` oder `leafpad`. Beide sind sehr rudimentäre Editoren deren Funktionsumfang aber vollkommen ausreicht. Für macOS' standard `TextEdit` muss man ein bisschen vorsichtig sein und darauf achten, beim Speichern explizit unter _Format_ die Option _Reiner Text_ auszuwählen.
|
||||
|
||||
Ansonsten ist es empfehlenswert, einen Editor herunterzuladen der für die Programmierung und das Bearbeiten von Code ausgelegt ist wie z.b [Notepad++](http://notepad-plus-plus.org/), [Sublime Text](https://www.sublimetext.com/) oder [VS Code](https://code.visualstudio.com/).
|
||||
|
||||
?> Immer noch unsicher, welcher Text Editor der Richtige für Dich ist? Laurence Bradford hat eine hervorragende [Einleitung](https://learntocodewith.me/programming/basics/text-editors/) zu dem Thema geschrieben (auf Englisch).
|
||||
|
||||
### QMK Toolbox
|
||||
|
||||
QMK Toolbox ist ein optionales grafisches Programm für Windows und macOS, das es erleichtern soll, deine Tastatur zu programmieren und zu debuggen. Du wirst es höchstwahrscheinlich früher oder später als unverzichtbar ansehen, wenn es darum geht eine Tastatur einfach zu flashen oder zu debuggen, da es ermöglicht, sich debug-Nachrichten direkt anzeigen zu lassen.
|
||||
|
||||
[Hier kannst Du die aktuelle Version herunterladen.](https://github.com/qmk/qmk_toolbox/releases/latest)
|
||||
|
||||
* Für Windows: `qmk_toolbox.exe` (portable) oder `qmk_toolbox_install.exe` (installer)
|
||||
* Für macOS: `QMK.Toolbox.app.zip` (portable) oder `QMK.Toolbox.pkg` (installer)
|
||||
|
||||
## Die Entwicklungsumgebung aufsetzen
|
||||
|
||||
|
||||
Wir haben versucht, die Installation der Entwicklungsumgebung für QMK so einfach wie möglich zu gestalten. Alles, was Du tun musst, ist eine Linux oder Unix Umgebung aufzusetzen, danach macht QMK den Rest.
|
||||
|
||||
?> Wenn Du das erste Mal mit der Linux/Unix Befehlszeile arbeitest, schadet es nicht, sich mit ein paar Grundlagen und Befehlen vertraut zu machen. Diese Ressourcen sollten ausreichen, um sich das Nötigste anzueignen um mit QMK arbeiten zu können:<br>
|
||||
[Erforderliche Linux Grundlagen](https://www.guru99.com/must-know-linux-commands.html)<br>
|
||||
[Noch ein paar Linux Befehle](https://www.tjhsst.edu/~dhyatt/superap/unixcmd.html)
|
||||
|
||||
### Windows
|
||||
|
||||
Du wirst MSYS2 (o.Ä.) und Git benötigen.
|
||||
|
||||
* Befolge die Installationsanleitung auf der [MSYS2 Homepage](http://www.msys2.org)
|
||||
* Schließe alle offenen MSYS2 Fenster und öffne ein neues MSYS2 MinGW 64-bit Terminal
|
||||
* Installiere Git mit dem Kommando: `pacman -S git`
|
||||
|
||||
### macOS
|
||||
|
||||
Du wirst Homebrew benötigen. Folge dafür den Anweisungen auf der [Homebrew homepage](https://brew.sh).
|
||||
|
||||
Nachdem Homebrew erfolgreich installiert ist, kannst Du mit _QMK aufsetzen_ fortfahren.
|
||||
|
||||
### Linux
|
||||
|
||||
Du benötigst Git, aber es ist ziemlich wahrscheinlich, dass es bereits installiert ist. Sollte dies nicht der Fall sein, kannst Du es mit dem folgenden Aufruf installieren:
|
||||
|
||||
* Debian / Ubuntu / Devuan: `apt-get install git`
|
||||
* Fedora / Red Hat / CentOS: `yum install git`
|
||||
* Arch Linux: `pacman -S git`
|
||||
|
||||
?> Docker ist ebenfalls eine Option für alle Plattformen. [Hier](de/getting_started_build_tools.md#docker) kannst Du dazu weitere Informationen finden.
|
||||
|
||||
## QMK aufsetzen
|
||||
Wenn Du damit fertig bist, deine Linux/Unix Umgebung zu installieren, kannst Du damit fortfahren QMK herunterzuladen. Dafür werden wir mit Git das QMK Repository "klonen". Öffne ein Terminal oder ein MSYS2 MinGW Fenster, dies wirst Du für den Rest der Anleitung benötigen. In diesem Fenster rufst Du nun die beiden folgenden Kommandos auf:
|
||||
|
||||
```shell
|
||||
git clone --recurse-submodules https://github.com/qmk/qmk_firmware.git
|
||||
cd qmk_firmware
|
||||
```
|
||||
?> Wenn Du bereits weißt, [wie man GitHub benutzt](de/getting_started_github.md), empfehlen wir, dass Du Dir ein eigenen Fork erstellst. Wenn Du nicht weißt, was das bedeuten soll, kannst Du diesen Ratschlag getrost ignorieren.
|
||||
|
||||
QMK liefert ein Script mit, das helfen soll, Dir alles Weitere abzunehmen. Du kannst es mit dem folgenden Befehl aufrufen:
|
||||
|
||||
util/qmk_install.sh
|
||||
|
||||
## Die Build-Umgebung testen
|
||||
|
||||
Nun sollte hoffentlich alles Nötige für eine funktionierende QMK Build-Umgebung installiert sein und Du solltest in der Lage sein, die QMK-Firmware zu kompilieren. Um dies mit einer `default` Tastaturbelegung zu testen, kannst Du den folgenden Befehl ausprobieren:
|
||||
|
||||
make <keyboard>:default
|
||||
|
||||
Der Befehl um z.B. die Firmware für ein _Clueboard 66%_ zu erzeugen lautet:
|
||||
|
||||
make clueboard/66/rev3:default
|
||||
|
||||
Wenn es fertig ist, sollte der Output ungefähr so ähnlich wie das Folgende aussehen:
|
||||
|
||||
```
|
||||
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)
|
||||
```
|
||||
|
||||
# Eine eigene Tastaturbelegung erstellen
|
||||
Du bist nun fertig mit dem Setup der Entwicklungsumgebung und solltest somit in der Lage sein, deine eigenen Tastaturbelegungen zu erstellen. Um fortzufahren, folge bitte der nächsten Anleitung unter [Die erste Firmware](de/newbs_building_firmware.md).
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
# Lernmaterial
|
||||
|
||||
Diese weiterführenden Ressourcen sind darauf ausgerichtet, Neulingen der QMK Commmunity mehr Informationen und ein besseres Verständnis zu einzelnen Themen zu bieten.
|
||||
|
||||
Git Ressourcen:
|
||||
|
||||
* [Gutes allgemeines Tutorial](https://www.codecademy.com/learn/learn-git) (auf Englisch)
|
||||
* [Git spielerisch anhand von Beispielen lernen](https://learngitbranching.js.org/) (auf Englisch)
|
||||
* [Mehr über den allgemeinen Umgang mit Github](getting_started_github.md)
|
||||
* [Mehr über Git im Bezug zu QMK](contributing.md)
|
||||
|
||||
Mehr über die Arbeit mit der Befehlszeile:
|
||||
|
||||
* [Gutes allgemeines Tutorial über die Arbeit mit der Befehlszeile](https://www.codecademy.com/learn/learn-the-command-line) (auf Englisch)
|
||||
|
|
@ -0,0 +1,100 @@
|
|||
# Testen und Debuggen
|
||||
|
||||
Nachdem Du deine Tastatur mit deiner angepassten Firmware geflasht hast, ist es nun an der Zeit sie auszuprobieren. Mit ein bisschen Glück sollte alles ohne Probleme funktionieren, wenn dies nicht der Fall ist, soll dieses Dokument dir dabei helfen, herauszufinden wo das Problem liegt.
|
||||
|
||||
## Testen
|
||||
|
||||
Die Tastatur zu testen ist relativ selbsterklärend. Drücke jede der Tasten um dich zu versichern, dass der gesendete Keyode der ist, den du erwarten würdest. Dafür gibt es sogar ein paar Programme die helfen sollen, dass keine Taste ausgelassen wurde.
|
||||
|
||||
Anmerkung: Diese Programme werden weder von QMK bereitgestellt oder gutgeheißen.
|
||||
|
||||
* [Switch Hitter](https://elitekeyboards.com/switchhitter.php) (Nur für Windows)
|
||||
* [Keyboard Viewer](https://www.imore.com/how-use-keyboard-viewer-your-mac) (Nur für Mac)
|
||||
* [Keyboard Tester](http://www.keyboardtester.com) (Web basiert)
|
||||
* [Keyboard Checker](http://keyboardchecker.com) (Web basiert)
|
||||
|
||||
## Debuggen
|
||||
|
||||
Deine Tastatur wird Debug Informationen liefern wenn Du `CONSOLE_ENABLE = yes` in deiner `rules.mk` gesetzt hast. Die default-Ausgabe ist sehr beschränkt und kann wenn nötig durch die Aktivierung des Debug-Modes erhöht werden. Benutze dafür entweder den `DEBUG` Keycode in deiner Tastaturbelegung, das [Command](de/feature_command.md)-Feature oder füge den folgenden Code zu deiner Tastaturbelegung hinzu.
|
||||
|
||||
```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;
|
||||
}
|
||||
```
|
||||
|
||||
### Debuggen mit der QMK Toolbox
|
||||
|
||||
Für kompatible Plattformen kann die [QMK Toolbox](https://github.com/qmk/qmk_toolbox) benutzt werden um Debug-Nachrichten deiner Tastatur anzuzeigen.
|
||||
|
||||
### Debuggen mit hid_listen
|
||||
|
||||
Bevorzugst Du es lieber auf der Befehlszeile zu debuggen? Dafür eignet sich das Programm [hid_listen](https://www.pjrc.com/teensy/hid_listen.html) von PJRC. Binaries sind für Windows, Linux und MacOS verfügbar.
|
||||
|
||||
<!-- FIXME: Describe the debugging messages here. -->
|
||||
|
||||
## Eigene Debug-Nachrichten senden
|
||||
|
||||
Manchmal ist es hilfreich Debug-Nachrichten innerhalb deines eigenen [Custom Codes](de/custom_quantum_functions.md) zu drucken. Das ist ziemlich einfach. Beginne damit `print.h` am Anfang deiner Datei zu inkludieren:
|
||||
|
||||
#include <print.h>
|
||||
|
||||
Danach stehen dir verschiedene Druck-Funktionen zur Verfügung:
|
||||
|
||||
* `print("string")`: Druckt einen simplen String
|
||||
* `uprintf("%s string", var)`: Druckt einen formatierten String
|
||||
* `dprint("string")` Druckt einen simplen String, aber nur wenn der Debug-Mode aktiviert ist
|
||||
* `dprintf("%s string", var)`: Druckt einen formatierten String, aber nur wenn der Debug-Mode aktiviert ist
|
||||
|
||||
## Debug Beispiele
|
||||
|
||||
Anbei findest Du eine Sammlung von hilfreichen Beispielen. Für weitere Informationen Informationen sei an dieser Stelle auf [Debugging/Troubleshooting QMK](de/faq_debug.md) verwiesen.
|
||||
|
||||
### Which matrix position is this keypress?
|
||||
### Welche Matrix Position hat dieser Tastenanschlag
|
||||
|
||||
Beim Portieren, oder bei der Fehlerdiagnose von PCB Problemen, ist es nützlich sich anzeigen zu lassen ob ein Tastenanschlag richtig erkannt wurde. Um die Protokollierung für diesen Fall zu aktivieren, füge bitte folgenden Code zu deiner Tastaturbelegung `keymap.c` hinzu.
|
||||
|
||||
```c
|
||||
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
|
||||
// Wenn 'console' aktiviert ist wird die Matrix-Position und der Status jedes Tastenanschlags ausgegeben
|
||||
#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;
|
||||
}
|
||||
```
|
||||
|
||||
Beispiel Ausgabe:
|
||||
```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
|
||||
```
|
||||
|
||||
### Wieviel Zeit wurde benötigt um einen Tastenanschlag zu detektieren?
|
||||
|
||||
Wenn Performance-Probleme auftreten ist es hilfreich die Frequenz, mit der die Matrix gescannt wird, zu wissen. Um dies in diesem Fall zu aktiveren füge, den folgenden Code zu deiner Tastaturbelegung in `config.h` hinzu.
|
||||
|
||||
```c
|
||||
#define DEBUG_MATRIX_SCAN_RATE
|
||||
```
|
||||
|
||||
Beispiel Ausgabe
|
||||
```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
|
||||
```
|
||||
Loading…
Reference in New Issue