Eigenes MacroPad bauen: mit Raspberry Pi Pico zum Effizienz-Booster

Wie du dir ein MacroPad mit dem Raspberry Pi Pico aufbaust und programmierst, zeige ich dir hier in meinem neuen Beitrag. Dieses MacroPad kann ein echter Effizenz-Booster sein und dich bei deiner täglichen Arbeit unterstützen.

Eigenes MacroPad bauen: mit Raspberry Pi Pico zum Effizienz-Booster

Dieses Video auf YouTube ansehen.

In der ersten Version hatte mein MacroPad lediglich sechs Tasten und lief schon recht gut, die zweite Version habe ich um drei weitere Tasten und drei Rotary Encoder erweitert und somit auf das nächste Level gehoben. Ein zusätzliches Feature ist ein einfacher Schiebeschalter, mit welchen man programmatisch die Tasten doppelt belegen kann.

Inhaltsverzeichnis

• Warum kann ein MacroPad ein Effizienz-Booster sein?
• Was wird für den Aufbau eines MacroPad’s benötigt?
  • Werkzeuge
  • Warum nicht den neuen Raspberry Pi Pico 2?
• Flashen des Mikrocontrollers für die Programmierung in CircuitPython
• Aufbau der Schaltung – Taster am Raspberry Pi Pico
• Programmierung des MacroPad in CircuitPython
  • Schritt 1 – programmieren eines Tasters mit CircuitPython am RP2040
  • Schritt 2 – ausführen einer Tastaturaktion via Taster
    • Schritt 2.1 – deutsches Tastaturlayout verwenden
  • Schritt 3 – Schreiben von Texten via Tasteraktion
    • Schritt 3.1 – Dictionary für unterschiedliche Taster
• Fazit – MacroPad mit Raspberry Pi Pico

Warum kann ein MacroPad ein Effizienz-Booster sein?

Ein MacroPad kann die Produktivität erheblich steigern, indem es wiederkehrende PC-Aktionen auf einfache Weise automatisiert. Hier sind die wichtigsten Vorteile:

• Zeitersparnis: Ein Knopfdruck ersetzt wiederholte Tastenkombinationen und Menüaktionen.
• Personalisierte Steuerung: Es lässt sich individuell programmieren, um häufig genutzte Funktionen direkt auszuführen.
• Vereinfachung komplexer Prozesse: Mehrere Arbeitsschritte können in einem Makro zusammengefasst werden.
• Fehlerreduktion: Automatisierte Abläufe minimieren menschliche Fehler.
• Ergonomische Vorteile: Weniger wiederholte Handbewegungen reduzieren körperliche Belastung.
• Anpassung für verschiedene Programme: Das MacroPad kann je nach Software unterschiedliche Befehle übernehmen.
• Multitasking-Unterstützung: Es erleichtert das parallele Arbeiten mit mehreren Programmen.

Insgesamt wird die Arbeit schneller, einfacher und komfortabler.

Was wird für den Aufbau eines MacroPad’s benötigt?

Für das hier vorgestellte MacroPad habe ich nachfolgende Bauteile benötigt:

Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Werkzeuge

Neben einer vernünftigen Lötstation oder Lötkolben benötigst du noch:

• einen Seitenschneider
• eine Abisolierzange
• eine Flachzange

Die Flachzange benötigst du, um die starren 20 AWG Kabel zu biegen. Natürlich geht dieses auch mit der Hand nur so, hast du schöne 90° Winkel.

Warum nicht den neuen Raspberry Pi Pico 2?

Flashen des Mikrocontrollers für die Programmierung in CircuitPython

Um automatisierte Aktionen ausführen zu können, sind spezielle Features erforderlich, die nur CircuitPython bietet. Dazu muss der Mikrocontroller zunächst mit einer speziellen UF2-Datei bespielt werden, die es ermöglicht, CircuitPython auf dem Raspberry Pi Pico auszuführen. Diese Datei wird auf den Pico übertragen, indem man ihn in den Bootloader-Modus versetzt und die UF2-Datei auf das erscheinende Laufwerk kopiert.

Die UF2-Datei bekommst du unter https://circuitpython.org/board/raspberry_pi_pico/.

Zunächst musst du deinen Pico vom Computer trennen, um anschließend die Taste BOOT gedrückt zu halten und die Verbindung wieder herzustellen. Wenn dieses geschehen ist, dann solltest du ein neues Laufwerk im Explorer finden.

Im nächsten Schritt musst du dann die UF2-Datei auf dieses Laufwerk kopieren oder per Drag’n Drop ziehen. Der Mikrocontroller wird dann automatisch geflasht und neu gestartet.

Aufbau der Schaltung – Taster am Raspberry Pi Pico

Auf dem MacroPad kannst du einfache Taster, Touchsensoren, analoge Joysticks und auch Rotary Encoder verbauen. Im Nachfolgenden zeige ich dir zunächst eine Schaltung mit einem Taster.

Statt einfache Taster kannst du ebenso auch Touchsensoren verwenden, diese gibt es sehr günstig im 10er-Pack auf Aliexpress bereits ab 1,15 € zzgl. Versandkosten.

Im Nachfolgenden verwende ich den kleinen XIAO RP2040 welchen ich dir bereits im Beitrag Seeed Studio XIAO RP2040 – ein Zwerg mit großer Leistung vorgestellt habe. Dieser hat denselben Chip wie der originale Raspberry Pi Pico und kann somit problemlos eingesetzt werden.

Programmierung des MacroPad in CircuitPython

Für die Programmierung verwende ich die Entwicklungsumgebung Thonny, diese kannst du dir unter https://thonny.org/ kostenfrei für Windows, Linux und macOS herunterladen. Du könntest ebenso auch den MU-Editor verwenden oder auch Visual Studio etc. jedoch ist die Thonny IDE schlank und trotzdem sehr mächtig und daher meine erste Wahl bei der Entwicklung von kleinen Programmen auf dem Mikrocontroller.

Schritt 1 – programmieren eines Tasters mit CircuitPython am RP2040

Als Erstes erstellen wird ein Programm, welches das Event eines Tasters auswertet. Da wir in der Schaltung die Taster ohne PullUp / PullDown Widerstand angeschlossen haben, müssen wir dieses programmatisch lösen.

import board
from digitalio import DigitalInOut, Direction, Pull
import time

taster = DigitalInOut(board.D0)
taster.direction = Direction.INPUT
taster.pull = Pull.UP

def main():
    while True:
        if not taster.value:
	   print("Taster wurde gedrückt!")
	   time.sleep(0.5)

main()

Schritt 2 – ausführen einer Tastaturaktion via Taster

Damit eine Aktion über die Tastatur oder Maus ausgeführt werden kann, benötigen wir das Modul Adafruit HID welches wir vom GitHub Repository Adafruit / Adafruit_CircuitPython_HID als ZIP-Datei herunterladen können.

Auf der Seite https://docs.circuitpython.org/projects/hid/en/latest/ findest du eine sehr ausführliche Übersicht in englischer Sprache zum Funktionsumfang des Moduls.

Im nachfolgenden Beispiel wird bei Tastendruck der kleine Buchstabe a an der Position des Cursors geschrieben.

import board
from digitalio import DigitalInOut, Direction, Pull
import time

import usb_hid
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keycode import Keycode
from adafruit_hid.keyboard_layout_win_de import KeyboardLayout

kbd = Keyboard(usb_hid.devices)

taster = DigitalInOut(board.D0)
taster.direction = Direction.INPUT
taster.pull = Pull.UP

def main():
    while True:
        if not taster.value:
            kbd.press(Keycode.A)
	    time.sleep(0.09)
            kbd.release(Keycode.A)

main()

Möchte man einen großen Buchstaben schreiben, so muss man wie beim Schreiben auf der Tastatur die Shift-Taste gedrückt halten.

kbd.press(Keycode.SHIFT)
kbd.press(Keycode.A)
time.sleep(0.09)
kbd.release(Keycode.A)
kbd.release(Keycode.SHIFT)

Der Funktion press & release können auch mehr als nur ein Parameter vom Typ Keycode übergeben werden, somit können wir den obigen Code auch deutlich schlanker schreiben.

kbd.press(Keycode.SHIFT, Keycode.A)
time.sleep(0.09)
kbd.release(Keycode.SHIFT, Keycode.A)

Schritt 2.1 – deutsches Tastaturlayout verwenden

Per Default verwendet das Adafruit Modul ein englisches / amerikanisches Tastaturlayout, somit fehlen die Umlaute und auch verschiedene Tasten sind umbelegt, zum Beispiel liegt auf der Taste Z der Buchstabe Y usw.

Um dieses zu lösen, gibt es eine Python-Datei, welche wir vom GitHub Repository Neradoc / Circuitpython_Keyboard_Layouts unter /libraries/layouts/ herunterladen können.

import board
from digitalio import DigitalInOut, Direction, Pull
import time

import usb_hid
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keycode import Keycode
from adafruit_hid.keyboard_layout_win_de import KeyboardLayout

kbd = Keyboard(usb_hid.devices)
kbd_layout = KeyboardLayout(kbd)

taster = DigitalInOut(board.D0)
taster.direction = Direction.INPUT
taster.pull = Pull.UP

def main():
    while True:
        if not taster.value:
            kbd_layout.write("Hier steht ein sehr langer Text!")
	    time.sleep(0.5)

main()

Schritt 3 – Schreiben von Texten via Tasteraktion

Möchte man längere Texte ausgeben, so kann man die zuvor bereits gezeigte Funktion write am Keyboard_Layout Objekt verwenden.

kbd_layout.write("Hier steht ein sehr langer Text!")

Schritt 3.1 – Dictionary für unterschiedliche Taster

Wenn du mehrere Taster an deinen Mikrocontroller angeschlossen hast, dann empfiehlt es sich die Texte auszulagern. Hier bietet sich wiederum ein Dictionary an in welchem man die Texte in Schlüssel / Wertepaare auslagern kann.

import board
from digitalio import DigitalInOut, Direction, Pull
import time

import usb_hid
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keycode import Keycode
from adafruit_hid.keyboard_layout_win_de import KeyboardLayout

textbausteine = {
 "taster1":"Taster 1 wurde betätigt!",
 "taster2":"Der Taster 2 wurde gedrückt!",
 "taster3":"Am Taster 3 wurde ine Aktion ausgelöst!"
}

kbd = Keyboard(usb_hid.devices)
kbd_layout = KeyboardLayout(kbd)

taster1 = DigitalInOut(board.D0)
taster1.direction = Direction.INPUT
taster1.pull = Pull.DOWN

taster2 = DigitalInOut(board.D1)
taster2.direction = Direction.INPUT
taster2.pull = Pull.DOWN

taster3 = DigitalInOut(board.D2)
taster3.direction = Direction.INPUT
taster3.pull = Pull.DOWN

def main():
    while True:
        if taster1.value:
            kbd_layout.write(textbausteine["taster1"])
        if taster2.value:
            kbd_layout.write(textbausteine["taster2"])
        if taster3.value:
            kbd_layout.write(textbausteine["taster3"])

main()

Fazit – MacroPad mit Raspberry Pi Pico

Ein MacroPad lässt sich, wie du gesehen hast, mit dem Raspberry Pi Pico ganz unkompliziert umsetzen. Mit ein paar Tastern kannst du den hier gezeigten Code einfach nutzen und nach deinen Wünschen anpassen.

Falls du anstelle von Tastern Touchsensoren verwenden möchtest, kannst du diese dezent hinter Gehäusen oder Oberflächen platzieren. So lassen sich Aktionen ausführen, ohne dass jemand bemerkt, wie sie ausgelöst werden.