Die selbstgebaute Shortcut-Tastatur mit ESP32: Eine Bauanleitung für Maker

Autor: DerSchneider

Einleitung

Was haben Programmierer, Videoeditoren und 3D-Druck-Enthusiasten gemeinsam? Sie alle verlieren kostbare Zeit mit wiederkehrenden Tastenkombinationen. Strg+C, Strg+V, Alt+Tab – die linke Hand wandert über die Tastatur, die Augen suchen kurz die richtigen Tasten. Effizienter wäre ein dediziertes Bedienfeld, eine Makro-Tastatur mit programmierbaren Tasten, die genau die Befehle ausführt, die man täglich braucht.

In diesem Artikel zeige ich, wie man aus zwölf gebrauchten Cherry-Tasten, einem ESP32-Dev-Board und ein paar Lötverbindungen eine kompakte Shortcut-Tastatur baut. Anders als handelsübliche Stream Decks oder Elgato-Controller kostet dieses Projekt nur etwa 15–20 Euro – vorausgesetzt, die Tasten und das Gehäuse sind bereits vorhanden. Der Fokus liegt auf einer sauberen Code-Erklärung, damit jeder Maker die Firmware später selbst anpassen kann. Wir nutzen dabei die eingebaute Bluetooth-Funktion des ESP32, sodass die Tastatur kabellos mit PC oder Laptop kommuniziert – ein echter Gewinn an Flexibilität.

Hauptteil

1. Eine kurze Geschichte der programmierbaren Tastaturen

Die Idee, Tasten mit Makros zu belegen, ist fast so alt wie die Computertastatur selbst. Bereits in den 1980er-Jahren boten Btx-Terminals und frühe PCs wie der Commodore 64 die Möglichkeit, Funktionstasten mit benutzerdefinierten Befehlsfolgen zu belegen. Die eigentliche Revolution brachten jedoch Gaming-Tastaturen der 2000er Jahre: Razer, Logitech und Corsair integrierten zusätzliche Makro-Tasten, deren Belegung über Treiber-Software im Betriebssystem erfolgte.

Parallel dazu entwickelte sich die Open-Source-Bewegung im Bereich der Tastatur-Firmware. Projekte wie QMK (Quantum Mechanical Keyboard) und später ZMK erlaubten es Bastlern, vollständig eigene Tastaturen zu programmieren – inklusive Ebenen, Doppelfunktionen und komplexer Makros. Der ESP32, ursprünglich als WLAN/BT-Modul für IoT-Geräte konzipiert, fand dank seiner Fähigkeit, sich als Bluetooth-HID (Human Interface Device) zu tarnen, schnell den Weg in die Maker-Szene. Heute ist die Kombination aus ESP32 und der Bibliothek BleKeyboard der einfachste Einstieg in eine eigene drahtlose Makro-Tastatur – ohne tiefe Low-Level-Kenntnisse.

2. Hardware-Aufbau: Verkabelung ohne Matrix

2.1 Komponentenliste

2.2 Verdrahtungsprinzip

Da wir auf eine Diodenmatrix verzichten (die zwölf Tasten sind überschaubar), wird jeder Taster direkt an einen separaten GPIO-Pin und an GND angeschlossen. Das ist die einfachste Topologie, aber ohne Dioden besteht bei gleichzeitigem Drücken von drei oder mehr Tasten die Gefahr von Ghosting (Phantom-Tastensignale). Für reine Shortcut-Tasten, die üblicherweise einzeln gedrückt werden, ist das akzeptabel. Wer sichergehen möchte, lötet eine 1N4148-Diode in Reihe zu jedem Taster – das ist aber für dieses Projekt optional.

Anschlussplan (Taster 1..12):

• Jeder Taster: Ein Kontakt → GPIO aus untenstehender Liste, der andere Kontakt → GND (Masse).
• Die internen Pullup-Widerstände des ESP32 werden im Code aktiviert, daher keine externen Widerstände nötig.

Achtung: Die GPIOs 34, 35, 36 und 39 sind auf vielen ESP32-Boards nur als Eingänge nutzbar (keine internen Pullups!). Im Code muss hier INPUT statt INPUT_PULLUP verwendet werden, und ein externer 10 kΩ-Widerstand zwischen GPIO und 3,3 V ist erforderlich. Wir vereinfachen: Für die ersten acht Tasten wurden nur Pins mit Pullup-Fähigkeit gewählt.

2.3 Lötanleitung für Einsteiger

1. Vorbereitung: Entzinnen Sie die Lötpads der Cherry-Taster, falls sie bereits angelötet waren.
2. Kabel zuschneiden: Zwölf Stücke Litze à 10 cm.
3. Anlöten an die Taster: Jeweils ein Kabel an einen der beiden Kontakte jedes Tasters. Den zweiten Kontakt aller Taster verbinden Sie mit einer gemeinsamen GND-Leitung (z.B. als Sternpunkt).
4. Verbindung zum ESP32: Die zwölf einzelnen Kabel löten Sie an die oben genannten GPIO-Pins. Das gemeinsame GND-Kabel löten Sie an einen GND-Pin des ESP32.
5. Isolierung: Schrumpfschlauch oder Heißkleber verhindert Kurzschlüsse im Gehäuse.

Risikohinweis: Arbeiten Sie niemals an einem stromführenden ESP32. Ein versehentlicher Kurzschluss zwischen 3,3 V und GND kann den Chip zerstören.

3. Die Software: Code-Erklärung Schritt für Schritt

Die Firmware basiert auf der Arduino-IDE und der Bibliothek BleKeyboard von T-vK (GitHub-Repository: ESP32-BLE-Keyboard). Diese Bibliothek emuliert eine Bluetooth-Tastatur – jedes Drücken einer Taste auf dem ESP32 wird vom Betriebssystem als Tastendruck einer gewöhnlichen Bluetooth-Tastatur erkannt.

3.1 Vorbereitung der Arduino-IDE

1. Installieren Sie die Arduino-IDE (Version 2.x empfohlen).
2. Fügen Sie die ESP32-Board-URL hinzu: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json (unter Datei → Voreinstellungen → Zusätzliche Boardverwalter-URLs).
3. Installieren Sie das Boardpaket „ESP32“ (Version 3.0.0 oder neuer) über den Boardverwalter.
4. Installieren Sie die Bibliothek BleKeyboard über den Bibliotheksverwalter (Suche nach „BleKeyboard“ von T-vK).

3.2 Der vollständige Code (Version für die ersten acht Tasten)

cpp

#include <BleKeyboard.h>

// Erzeuge ein Bluetooth-Tastatur-Objekt mit dem Namen "Kerm-it-Shortcut"
BleKeyboard keyboard("Kerm-it-Shortcut");

// Liste der GPIO-Pins für Tasten 1..12 (in Reihenfolge)
const uint8_t pins[12] = {13,12,14,27,26,25,33,32,35,34,39,36};

void setup() {
  // Alle Pins als Eingänge mit internem Pullup-Widerstand konfigurieren
  for(int i = 0; i < 12; i++) {
    pinMode(pins[i], INPUT_PULLUP);
  }
  // Bluetooth-Tastatur starten
  keyboard.begin();
}

void loop() {
  // Jede Taste nacheinander abfragen
  for(int i = 0; i < 12; i++) {
    // LOW bedeutet: Taster gedrückt (weil der andere Pin an GND liegt)
    if(digitalRead(pins[i]) == LOW) {
      action(i);               // Führe die zugehörige Aktion aus
      while(digitalRead(pins[i]) == LOW); // Warte auf Loslassen (Entprellung)
      delay(20);               // Kurze Pause zur Stabilisierung
    }
  }
}

// Funktion für jede Taste (Index 0 = T1, 1 = T2, ...)
void action(int keyIndex) {
  switch(keyIndex) {
    case 0: // T1: Strg+C
      keyboard.press(KEY_LEFT_CTRL);
      keyboard.press('c');
      delay(100);
      keyboard.releaseAll();
      break;

    case 1: // T2: Strg+V
      keyboard.press(KEY_LEFT_CTRL);
      keyboard.press('v');
      delay(100);
      keyboard.releaseAll();
      break;

    case 3: // T4: Win+Shift+S
      keyboard.press(KEY_LEFT_GUI);   // Windows-Taste
      keyboard.press(KEY_LEFT_SHIFT);
      keyboard.press('s');
      delay(100);
      keyboard.releaseAll();
      break;

    case 4: // T5: Win+D (Desktop anzeigen)
      keyboard.press(KEY_LEFT_GUI);
      keyboard.press('d');
      delay(100);
      keyboard.releaseAll();
      break;

    case 5: // T6: Play/Pause Mediensteuerung
      keyboard.write(KEY_MEDIA_PLAY_PAUSE);
      break;

    case 6: // T7: Terminal starten (cmd.exe)
      keyboard.press(KEY_LEFT_GUI);
      keyboard.releaseAll();
      delay(300);
      keyboard.print("cmd");
      keyboard.press(KEY_RETURN);
      keyboard.releaseAll();
      break;

    case 7: // T8: Aktives Fenster schließen (Alt+F4)
      keyboard.press(KEY_LEFT_ALT);
      keyboard.press(KEY_F4);
      delay(100);
      keyboard.releaseAll();
      break;

    // T3, T9–T12 noch nicht belegt
    default:
      break;
  }
}

3.3 Zeile-für-Zeile-Erklärung der wichtigsten Blöcke

• #include <BleKeyboard.h>
  Bindet die Bibliothek ein, die alle Bluetooth-HID-Operationen bereitstellt.
• BleKeyboard keyboard("Kerm-it-Shortcut");
  Erzeugt eine Instanz. Der String „Kerm-it-Shortcut“ ist der Name, der beim Koppeln im Bluetooth-Menü erscheint.
• const uint8_t pins[12] = {...}
  Ein Array, das die GPIO-Nummern in der Reihenfolge der Tasten speichert. Die Indizes 0..11 entsprechen T1..T12.
• pinMode(pins[i], INPUT_PULLUP);
  Aktiviert den internen Pullup-Widerstand (ca. 30–50 kΩ). Dadurch liegt der Pin im Ruhezustand auf HIGH (3,3 V). Wenn der Taster gedrückt wird, verbindet er den Pin mit GND → der Pegel fällt auf LOW. Das spart externe Widerstände.
• keyboard.begin();
  Startet den Bluetooth-Stack und macht den ESP32 für den PC sichtbar. Erst danach reagiert das Gerät auf Tastendrücke.
• digitalRead(pins[i]) == LOW
  Abfrage, ob der Taster aktuell gedrückt ist. LOW bedeutet „gedrückt“, weil der Taster gegen Masse schaltet.
• while(digitalRead(pins[i]) == LOW);
  Ein einfaches Entprellverfahren: Das Programm bleibt in dieser leeren Schleife, bis der Taster wieder losgelassen wird. Dadurch wird die Aktion nur einmal pro Drück-Vorgang ausgeführt. Das ist sicherer als eine feste Wartezeit.
• keyboard.press(KEY_LEFT_CTRL);
  Simuliert das Herunterdrücken der linken Strg-Taste. Zusammen mit keyboard.press('c') ergibt das Strg+C. Nach delay(100) werden alle Tasten losgelassen (keyboard.releaseAll()).
• keyboard.write(KEY_MEDIA_PLAY_PAUSE);
  Sendet einen einzelnen Tastencode – hier den speziellen Medien-Play/Pause-Befehl. write drückt und lässt sofort los.
• keyboard.print("cmd");
  Sendet eine Zeichenkette (jeden Buchstaben einzeln). Zusammen mit der vorherigen Windows-Taste und anschließendem Enter wird die Ausführung von „cmd“ gestartet.
• keyboard.press(KEY_LEFT_ALT); keyboard.press(KEY_F4);
  Alt+F4 – der klassische Befehl zum Schließen des aktiven Fensters unter Windows.

4. Risiken und typische Fehlerquellen

5. Ausblick: Was kann man noch verbessern?

• Erweiterung auf 24 Tasten – durch eine Diodenmatrix (z.B. 6×4). Dann sind weniger GPIOs nötig, aber der Code wird komplexer (Spalten/Zeilen abfragen).
• RGB-Beleuchtung – adressierbare LEDs (WS2812) an einem weiteren GPIO-Pin und die Bibliothek FastLED.
• Akku-Betrieb – Einbau eines Lithium-Ionen-Akkus mit TP4056-Lademodul. Dann wird die Tastatur wirklich kabellos.
• Profilumschaltung – über einen zusätzlichen Taster oder eine lange gedrückte Taste verschiedene Key-Mappings laden (z.B. für Video-Bearbeitung vs. programmieren).
• Integration in QMK – wer tief in die Materie einsteigen möchte, kann QMK mit ESP32-Unterstützung nutzen (allerdings aufwändiger).

Fazit

Die selbstgebaute Shortcut-Tastatur mit ESP32 ist ein ideales Einstiegsprojekt für alle, die Hardware und Software kombinieren wollen. Mit weniger als 50 Zeilen aktivem Code, zwölf Tastern und einem gängigen Entwicklungsboard entsteht ein nützliches Werkzeug für den Arbeitsalltag. Der größte Vorteil gegenüber gekauften Makro-Pads: absolute Freiheit bei der Belegung, keine proprietäre Treibersoftware und die Gewissheit, jeden einzelnen Lötpunkt selbst gesetzt zu haben.

Freilich ist die Lösung nicht perfekt: Das Fehlen einer Diodenmatrix limitiert die maximale Tastenzahl auf etwa ein Dutzend, und die Bluetooth-Reichweite ist mit maximal zehn Metern für den Schreibtisch völlig ausreichend. Wer aber genau die Funktionen braucht, die wir hier eingebaut haben (Kopieren, Einfügen, Screenshot, Play/Pause, Terminal), erhält ein maßgeschneidertes Eingabegerät für weniger als den Preis einer mittleren Pizza-Lieferung.

Und das Beste: Der Code liegt auf GitHub (unter dem Benutzer Kerm-it), kann jederzeit erweitert werden und ist ein lebendiges Beispiel dafür, wie die Maker-Bewegung Technik demokratisiert. Also: Lötkolben an, ESP32 flashen – und die linke Hand darf sich endlich ausruhen.

Quellen

1. Espressif Systems. (2023). ESP32 Series Datasheet. Version 4.5. [Online] Abrufbar unter: https://www.espressif.com/sites/default/files/documentation/esp32_datasheet_en.pdf
2. T-vK. (2024). *ESP32-BLE-Keyboard – Arduino library for Bluetooth HID*. GitHub Repository. https://github.com/T-vK/ESP32-BLE-Keyboard
3. Arduino. (2025). ESP32 Board Installation Instructions. https://docs.arduino.cc/software/ide-2/tutorials/ide-2-board-manager#esp32
4. Cherry GmbH. (2022). MX Series – Technical Data Sheet. https://www.cherry-world.com/cherry-mx.html
5. Random Nerd Tutorials. (2024). ESP32 USB Keyboard (HID) – How to Emulate a Keyboard. https://randomnerdtutorials.com/esp32-usb-keyboard-hid-arduino/ (abgerufen am 7. März 2026)