Jogis flexibles Makropad

Wir basteln uns ein Makro-Pad mit Arduino und ein bisschen 3D-Druck!

Tastaturen haben üblicherweise 102 – 104 Tasten, manche mehr, manche weniger.
Für einige Anwendungen sind aber zusätzliche, abgesetzte Kleintastaturen ganz nützlich.
Beispielsweise ein Nummernblock, oder Tasten, mit denen man Makros abspielen lassen kann.

Mittlerweile kann man solche Teile aus Chinaland massenhaft kaufen.
Viel schöner ist es aber, wenn man sich so ein Teil selbst bastelt.
Dabei lernt man etwas und Spass macht es auch noch!
Das ist übrigens ganz einfach.

Der Einstieg bei mir war schwierig, weil es so viele verschiedene Anleitungen und Versionen gibt, die oft unvollständig waren, natürlich meistens auf englisch, oder als Youtube-Video mit dem Gesicht des Erschaffenden (ich will lieber das Projekt sehen!)
Deswegen gibt es hier meine ganz eigene Oldschool-Anleitung!
Schriftlich – Schritt für Schritt.
Viel Spass beim Lesen – oder gerne auch Nachbasteln!

Welche Hardware?

Die Hardwarefrage ist schnell gelöst.
Am günstigsten und auch am meisten verwendet, ist die Arduino-Plattform.
Für unser Tastaturprojekt benötigen wir allerdings eine etwas erweitere Funktion, da der Basis-Arduino die Funktionen für eine Stand-Alone-Tastatur nicht mitbringt.
Mindest-Version des Arduino ist der Leonardo.
Irgendein kompatibler Clone geht natürlich auch.

Der unterstützt die Verwendung als Tastatur und bringt alle Voraussetzungen für unser Projekt mit.
Allerdings ist das Ding mit den Abmessungen einer Kreditkarte viel zu groß!

Ich nutze daher den Arduino Pro Micro mit 32u4-Chip.

Der ist nur 35x19mm groß und damit kaum größer als eine Briefmarke.
Die Stromversorgung läuft über den USB-Anschluss ebenso wie der Datentransfer an den PC (oder sonstige Geräte).
Zusätzlich benötigt man irgendwelche Taster.
Die müssen einfach nur einen Schaltkreis schliessen.
Am flexibelsten sind MX-kompatible Taster, die auch in normalen mechanischen Tastaturen verbaut werden.
(Cherry MX oder irgendwelche von den hunderten Clonen aus Fernost)
Ich mag MX-Blue, die klackern so schön.

Die Tasten gibt es ebenfalls in jedem besser sortierten Fachgeschäft oder bei Aliexpress.

Schon ab einer Taste ist man dabei.
Ein BUZZER oder Notaus-Knopf?
6 Tasten in einer Reihe?
4×4 Tasten als Block?
Wir sind flexibel, ich werde mehrere Entwürfe basteln und vorstellen.
Das Projekt ist immer im Fluss! (Anmerkungen, Fragen und Fehlerkorrekturen sind gerne gesehen)

Das Gehäuse erstellt man einfach im 3D-Druck.
Für das erste Macropad mit einer Reihe von 6 Tastern habe ich hier mal ein Foto angehängt.

Hier sind 3 Tasten fertig verlötet und die Rückleitung geht schon über alle 6 Tasten.

Für einen Belegungsplan der Pins suchen wir im Web nach „arduino pro micro pinout“
Verwirrend ist, dass die verschiedenen Anleitungen verschiedene Anschlüsse verwenden.
Da muss man sich für eine entscheiden.

Es gibt Anleitungen mit Dioden und ohne, Verbindungen von Anschlüssen auf andere Anschlüsse, oder von Anschlüssen auf Masse. Anscheinend ist alles möglich.
Warum dies und das genau so funktioniert, die Info ist aber nur mühsam zu finden.


Die Dioden benötigt man, wenn man mit Matrix arbeitet, also einer Verschaltung beispielsweise 3×3 Schalter.
Sonst können die Ströme fehlgeleitet werden und falsche Impulse auslösen.
Mit einer Matrix benötigt man weniger Pins am Arduino (die sind ja auch nur begrenzt verfügbar).
Man spart ein paar Kabel.
Allerdings braucht man eine Diode pro Taste und hat entsprechend mehr Lötarbeit.

Die Schaltung auf Masse ist wohl die einfachste, aber weil ich „in einem System“ bleiben will, habe ich mich für die Verwendung eines Aus-/Eingangs entschieden.

Matrix?
Man kann die Taster so verschalten, dass alle auf einen Ausgang gehen, dann braucht man pro Taster einen Eingang.
Mit einer Matrix kann man die Taster in Reihen und Spalten verschalten. Ab einer gewissen Menge an Tasten ist das effizienter, ausserdem hat der Arduino nur eine begrenzte Anzahl Anschlüsse.

Damit der Strom aber in einer Matrix nicht den falschen Weg nimmt, muss man pro Taster zusätzlich eine Diode einbauen, quasi als „Türsteher“.

Bei EINEM Taster schliesst man den natürlich direkt an.

Ab 4 Tastern kann man dann mit einer 2×2-Matrix arbeiten.
Normal verschaltet hat man 4 Eingänge und 1 Ausgang, braucht also 5 Anschlüsse.
Bei der 2×2 Matrix 2 Reihen, 2 Spalten, also 4 Anschlüsse – schon einen gespart!
Aber zusätzlich muss man noch 4 Dioden einbauen.

Mein 6-Tasten-Makropad benötigt 6 Eingänge und 1 Ausgang, also 7 Anschlüsse am Arduino.
Mit Matrix wäre das als 2×3 möglich, braucht also nur 6 Anschlüsse, dafür aber zusätzlich 6 Dioden.
Hier lohnt sich der Mehraufwand noch nicht.

Mit 9 Tasten braucht man schon 10 Anschlüsse, mit einer Matrix nur 9. Grenzwertig.
Ab 16 Tasten, bei einem 4×4-Feld geht das dann nur noch mit einer Matrix.

Welche Software?

Die einfachste Software ist einfach die vom Arduino-Projekt selbst.
Mit ein paar Zeilen Code kann man eine fertige Tastatur basteln.
Eine alternative und viel mächtigere Software ist das QMK-Projekt.

Freie Software, für alle Betriebssysteme verfügbar und mit unendlich vielen Funktionen, speziell für Tastaturen (und andere Eingabegeräte) – genau das, was wir brauchen.

Oversized? Wer bei 1-4 Tasten bleibt, kommt mit Arduino-Basics aus.
Aber wir fangen gleich richtig an.
Der Einstieg ist etwas schwieriger, aber die Möglichkeiten sind viel mächtiger!

QMK

QMK ist eine freie und quelloffene Software
Es gibt mittlerweile Hersteller „normaler“ Tastaturen, die QMK unterstützen.
Für Makropads funktioniert die Software hervorragend.
Es werden sehr viele Microprozessoren unterstützt. Uns interessiert aktuell aber nur der Arduino Pro Micro.
Mit der Suche nach „keyboard qmk“ finden wir die Webseite der „QMK Firmware“
(Ich verlinke nicht gerne, weil Links schnell veralten, man manchmal für Links haftet und weil ein bisschen Eigeninitiative nie schadet)
Auf der Webseite qmk.fm (aktuell am 1.12.2024) finden wir einige Infos und auch die benötigte Software.
Es gibt einen QMK Configurator, mit dem man online Tastaturenlayouts basteln kann.
Das ist etwas unübersichtlich und bringt uns aktuell nicht viel.

Interessant ist vor allem der Keycode Overview mit einer Auflistung aller Tastencodes, die man verwenden kann. (Z.B. KC_A für den Buchstaben a)

Als allererstes installieren wir uns die Software lokal. Dafür gehen wir auf die Seite „getting startet“.
Wir laden uns das QMK MSYS herunter und starten es.
Es erscheint ein Fenster ähnlich einer Kommandozeile. Das ist das Eingabefenster von QMK.
Dort schreiben wir:

qmk setup

Die meisten Fragen beantworten wir mit JA / YES

Nötig, oder unnötig, es steht so in der Anleitung: im nächsten Schritt kopieren wir die vorhandenen Tastaturenlayouts aus dem Web und wechseln in das Verzeichnis der Tastaturen.
(übrigens – im Zweifel einfach mit der Original-Anleitung abgleichen. Vielleicht hat sich ja zwischenzeitlich was geändert?)

git clone https://github.com/qmk/qmk_firmware.git
cd qmk_firmware

Unter Windows (ja, ich hab mal nicht mit Linux gearbeitet, sondern mit einem alten Bastelrechner) liegt das System unter c:\QMK_MSYS, die Tastaturen unter Deinem Benutzerverzeichnis, bei mir also unter C:\Users\jochen\qmk_firmware\keyboards

Funktionstest:

qmk compile -kb clueboard/66/rev3 -km default

Wir kompilieren einfach irgendeine der Tastaturen, obiges Beispiel ist von der offiziellen Webseite.
Wenn wir alles richtig installiert haben, sollte das so funktionieren.
Dann können wir loslegen!

Wir geben ein (wir befinden uns immer noch im Fenster von QMK!):

qmk new-keyboard

Damit erstellen wir eine komplett neue Tastatur!

Als erstes werden wir nach einem Namen der Tastatur gefragt.
Ich hab mein Projekt 00test genannt – das 00 deswegen, weil es damit in der Tastaturliste ganz oben steht und später leichter zu finden ist! Jeder andere Name geht natürlich auch.

Als nächstes müssen wir unseren Github Usernamen eingeben – wenn wir den nicht haben, müssen wir uns evtl. erst bei Github registrieren. Fake-Name habe ich nicht ausprobiert, aber GITHUB ist sowieso nützlich, also kann man sich da ruhig anmelden. Als Real-Name dann den korrekten Namen oder ja, Ihr wisst schon 🙂

Im nächsten Schritt müssen wir das gewünschte Layout angeben.
Die korrekte Nummer aus der Liste kann ich Euch nicht sagen, weil es immer mehr werden – beim Schreiben dieses Blogs war es 65 – NONE OF THE ABOVE, also KEINE – wir basteln ja ein eigenes Layout!

Using a Development Board? Noe, wir löten direkt am Arduino 🙂

Als nächstes müssen wir den verwendeten Prozessor auswählen – ganz wichtig!
Auch hier können sich die Nummern verschieben. Wir suchen den atmega32u4, das ist unser Arduino Pro Micro

Danach ist das Keyboard-Verzeichnis fertig angelegt, jetzt kommt die Handarbeit!
Da mein Projekt 00test heisst, finden wir das Verzeichnis unter keyboards\00test

Damit das Kompilieren nachher auch funktioniert, müssen wir noch eine rules.mk-Datei erstellen.
Wird in den meisten Anleitungen nicht erwähnt.
Also im Verzeichnis unter keyboards\00test eine Datei rules.mk anlegen mit dem Inhalt

DEFAULT_FOLDER = 00test

Damit ist klar, wo unsere Projekt liegt.

Im Verzeichnis gibt es eine Datei keyboard.json, die müssen wir etwas verändern.
Der Bootloader steht vermutlich auf atmel-dfu, den müssen wir auf caterina ändern (das ist einfach der Name für unseren Prozessor, hat sich irgendwer so ausgedacht)

Bei den Matrix_Pins müssen wir ebenfalls was ändern:

    "matrix_pins": {
         "cols": ["C6", "D7", "E6", "B3", "B2", "B6"],
         "rows": ["D4"]
    },

Das sind einfach nur die Anschluss-Pins am Arduino Pro Micro.
Lästigerweise sind die Pins mehrfach belegbar und die Aufschriften stimmen nicht mit den Angaben in der Software überein.
In diesem Projekt habe ich die Werte einfach von anderen Projekten übernommen.
Der Anschluss für die „gemeinsame“ Datenleitung ist der Pin D4 (ROW) – nur eine Reihe!
Auf dem Foto oben ist das der Pin mit der Bezeichnung 4!
Man könnte auch 3 Zeilen und 2 Spalten machen, aber dann muss man anders verkabeln und benötigt die angesprochenen Dioden. Für unser kleines Projekt ist es so einfacher.
Diese Leitung wird von Schalter zu Schalter durchverbunden. Im Foto die blaue Leitung:

Also löten wir eine Leitung von Pin 4 an jeweils einen Pin an jeden Schalter.
Welche Seite wir nehmen, ist egal, schön ist es, wenn man immer die gleiche Seite nimmt 🙂
Beim Löten aufpassen – ich hab mit dem Lötkolben gleich mal das Gehäuse angeschmolzen.

Bei der Zeile brauchen wir dann 6 Anschlüsse (cols).
Die Werte entsprechen folgenden Pins auf dem Foto des Arduino Pro Micro:
C6 = 5, D7 = 6, E6 = 7 – ziemlich verwirrend.
Für D7 gibt es beispielsweise die Bezeichnung 6 (das Aufgedruckte), oder A7, oder 27 – da blickt ja niemand durch.
Um einfacher löten zu können, habe ich die anderen 3 Schalter einfach auf der anderen Seite angelötet:
B3 = 14, B2=16, B6=10 – selbst die Reihenfolge auf dem Board ist durcheinander.
Da darf man sich nicht zu viele Gedanken machen. Hauptsache, die Zuordnung stimmt.
Wie man sieht, gibt es noch viel mehr Anschlussmöglichkeiten.
Für unsere 6 Taster reicht das erst einmal.

Die Datei keyboard.json und rules.mk sind fertig.

Beim Kompilieren gab es noch Fehler, ich musste noch das Verzeichnis base anlegen (–\00test\base) und da noch eine keyboard.json einbauen, die ich von einem anderen Projekt kopiert habe.
Der Inhalt dieser keyboard.json im base-Verzeichnis – nicht verwechseln mit der im Projektverzeichnis:

{
    "keyboard_name": "00test",
    "usb": {
        "pid": "0x0060"
    },
    "indicators": {
        "caps_lock": "B6"
    }
}

Unter keymaps – default (keyboards\00test\keymaps\default) gibt es die Datei keymap.c

Dort werden für unsere Tasten festgelegt, was an den Computer gesendet werden soll, wenn wir die Taste drücken.
Da wir nur eine Zeile haben, ist das recht einfach. Wir listen einfach die 6 Tastencodes nacheinander auf.
(Die Keycodes gibts auf der qmk-Webseite: https://docs.qmk.fm/keycodes)

// Copyright 2023 QMK
// SPDX-License-Identifier: GPL-2.0-or-later

#include QMK_KEYBOARD_H

const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    [0] = LAYOUT(
        KC_A, KC_B, KC_C, KC_D, KC_F13, KC_F14
    )
};

Ich habe einfach mal mit abcd angefangen, am Ende etwas mutiger mit den Sondertasten F13 und F14.
Später will ich dann auf F13 – F18 umsteigen. Die gibt es auf den meisten Tastaturen nicht und daher kann man die gut nutzen.

Fertig!
Jetzt können wir die Firmware für unsere Tastatur kompilieren.

qmk compile -kb 00test -km default

Das 00test ist der Name unserer Tastatur, der Rest ist Standard (da gibt es natürlich später viel mehr Möglichkeiten.
Auf meinem Uralt-Bastel-PC hat das übrigens ewig gedauert.

Irgendwann sollte dann so eine Meldung kommen – The firmware size is fine.
3 Zeilen weiter oben steht der Name der Firmware, der ist wichtig!
In unserem Fall 00test_default.hex.

FLASHEN!

Das ist schon die halbe Miete, jetzt müssen wir den Arduino Pro Micro nur noch flashen:

Falls noch nicht gemacht, gehen wir wieder auf die QMK-Webseite und laden uns die QMK-Toolbox herunter.
Toolbox installieren und starten. Beim ersten Start will die Software Treiber installieren. Dazu müssen wir das Programm mit Admin-Rechten starten (Rechte Maustaste – Als Administrator ausführen)

Wir klicken auf Open und laden die Firmwaredatei, die wir gerade erzeugt haben.
Die liegt unter c:\users\Benutzername\qmk_firmware\.build, für Benutzername setzt Du Deinen Username ein.

Übrigens – wenn Du Deinen Arduino genau so belegt hast, wie ich und wenn Du mit den Tasten F13 bis F18 zufrieden bist, dann kannst du einfach mein fertiges Flashfile nehmen und musst Dir keine eigene basteln:

Jogis Flash für 1×6-Makrotastatur mit F13 bis F18

(Download-Link von meinem Server, aber wie immer auf eigenes Risiko)

Jetzt sind wir bereit, den Arduino Pro Micro mit QMK zu flashen – Trommelwirbel…!

Wir stecken den Arduino an und theoretisch sollte er sofort als USB Gerät erkannt werden.
Um zu flashen, muss man die beiden Ports RST (Reset) und GND (Ground) verbinden, die sind direkt nebeneinander.
Dazu geht ein kleines Stück Kabel, ein Schraubenzieher, usw.
Aufpassen -das Flashen geht ratzfatz, hier der Screenshot vom Ablauf – keine 5 Sekunden:

Jetzt ist die Kiste bereit!

Wir starten den integrierten KEY-Tester in der QMK-Toolbox und hoffen, dass beim Verbinden der Anschlüsse eine Tasteneingabe registriert wird.
Also ein Kabel von 5 nach 4 gesteckt, sollte den Buchstaben A anzeigen, usw.

Drucken, Löten, Fertig!

Jetzt müssen wir nur noch ein kleines Gehäuse basteln.

Dafür gibt es ja idealerweise den 3D-Druck.
Ich hab da auch schon mal was vorbereitet.

Meine Druckdatei für 3D-Drucker gibt es bei Makerworld. Einfach hier draufklicken.

Da die Tasten von vorne gesteckt, aber von hinten gelötet werden, muss man die Tasten zuerst in das Gehäuse stecken. Dabei darauf achten, dass alle gleich ausgerichtet sind (siehe Foto)

Dann die eine Seite durchgehend mit dem Eingang verbinden (Erdung, gemeinsamer Pol, egal wie Ihr das nennt) und in unserem Beispiel mit Pin 4 verlöten.
Die anderen Pins der Schalter wie oben angelegt mit den entsprechenden Ausgängen am Arduino verlöten.
Wenn alles fertig ist, kann man einen kleinen Funktionstest machen.
Funktionieren alle Tasten?
Dann Gehäuse schliessen, Makropad einstecken und fertig!

Das Zusammenstecken ist der Kabel wegen etwas umständlich.
Deckel und Zwischenteil zusammenstecken, dann alle Kabel sorgfältig in das Zwischenteil drücken, so dass nur noch der Arduino etwas raushängt.
Unterteil schräg ansetzen und Arduino so reinstecken, dass der USB-Anschluss rausschaut.
Idealerweise noch ein Stück doppelseitiges Klebeband zur Fixierung verwenden.
Dann vorsichtig zuklappen, aufpassen, dass man keine Kabel einklemmt.
Alles korrekt zusammegesteckt?
Der Druck sollte leicht einrasten und nicht ausseinanderfallen. Es sollte nichts wackeln.
Wer will kann das Zwischenteil auch mit etwas Klebstoff am Oberteil befestigen.
Komplett zukleben würde ich es aber nicht, damit man für Wartungsarbeiten noch dran kommt.
Will man QMK mit anderen Tastencodes flashen, muss man an die obengenannten Pins drankommen.

Wie gesagt – vorsichtig zusammenstecken, dann ist man auch schon fertig.


Die Möglichkeiten sind unendlich – Maus-Simulator, Joystick-Simulator, Tastatur, Einzeltaste, Makropad.
Der Fantasie sind keine Grenzen gesetzt!

Viel Spass!

Ich übernehme übrigens keine Haftung!
Nach obiger Anleitung habe ich nebenher selbst noch ein Makropad zusammengebastelt, es sollte also funktionieren.

Übrigens

Der Aufwand, selbst für so einen kleinen Blog-Beitrag und so ein kleines Bastel-Dingens ist enorm.
Hier das fertige Makropad zusammen mit den Testdrucken, die dann doch irgendwie nicht gepasst haben.
Sieht einfach aus, braucht aber doch ein wenig Aufwand.
Würde mich daher freuen, wenn Euch der Beitrag gefällt 🙂