Als Smart-Home-Enthusiast setze ich stark auf intelligente Beleuchtung. Als ich jedoch jeden Raum im eigenen Haus mit einem Lichtregler ausstatten musste – manchmal sogar mit mehreren –, stieß ich auf ein Budgetproblem. Kommerzielle Smart-Home-Regler sind recht teuer. Daher beschloss ich, einen 3D-Drucker zu nutzen, etwas Elektronik hinzuzufügen und einen coolen maßgeschneiderten Regler zu einem Bruchteil des Preises zu bauen.

Ich habe ein kleines Makro-Pad entwickelt, bestehend aus Schaltern für eine mechanische Tastatur, einem ESP32-Board, einem Drehgeber zur Helligkeitsregelung und einem kompakten OLED-Display zur Anzeige der aktuell aktiven Lichtszenen. Der Drehgeber verfügt zudem über einen integrierten Druckschalter – durch Drücken wird der Display-Dimmmodus aktiviert, um die OLED-Helligkeit anzupassen, und durch erneutes Drücken kehrt man zur normalen Lichtsteuerung zurück.

Um sicherzustellen, dass es mehr als nur eine weitere langweilige Plastikbox wird, beschloss ich, mehrere Prusament Woodfill-Materialien zu kombinieren, um schöne Farbkombinationen zu schaffen, die zur Holzplatte meines Schreibtisches passen. Ich hatte die Gelegenheit, eines der Beta-Geräte des Prusa CORE One+ INDX zu testen, also nutzte ich dessen Multimaterial-Fähigkeiten. Sie können dieses Projekt jedoch problemlos auf einem Original Prusa XL drucken, einem Drucker, der mit einer MMU3 ausgestattet ist, oder sogar auf einem Standarddrucker ohne Multimaterial-Fähigkeiten. In diesem Fall müssen Sie die Filamente während des Druckvorgangs ein paar Mal manuell wechseln, was jedoch durchaus machbar ist – allerdings sollten Sie mit mehr Verschnitt rechnen. Dank der Verwendung des INDX hatte ich am Ende fast keinen Filamentabfall – ein großer Pluspunkt für das Projekt, da ich Material gespart habe, das ich nun zum Drucken weiterer Makropads oder anderer Dinge verwenden kann.

Hardware

Um dieses Projekt erschwinglich zu halten, lassen sich alle elektronischen Bauteile für nur wenige Euro beschaffen. Sie können natürlich auf das Display und den Encoder verzichten und sich nur auf die Schalter beschränken oder sogar die Anzahl der Tasten reduzieren.

Als „Gehirn“ des Macropads können Sie fast jedes ESP32- oder ähnliche Entwicklungsboard mit genügend Eingängen und einer WLAN-Verbindung verwenden. Hochwertige Boards von Marken wie Adafruit (wie das kompakte QT Py ESP32-S3 oder das klassische Feather ESP32-S3) oder SparkFun (das Thing Plus ESP32-S3) sind hierfür die perfekte Wahl. In meinem Fall habe ich, bevor ich online einkaufen ging, tief in meiner endlosen Schublade mit Ersatzteilen gegraben und ein ähnliches Board gefunden, ein Xiao ESP32-C3 von Seeed Studio, also habe ich beschlossen, es für diesen Bau zu verwenden.

Was die Tasten angeht, habe ich mich für mechanische Blue-Tastenschalter entschieden. Das mag etwas nischig sein, und normale Tasten würden auch einwandfrei funktionieren, aber mechanische Schalter gefallen mir einfach besser, wegen des befriedigenden Klickgefühls und -geräuschs.

Hier ist eine kurze Übersicht darüber, was Sie für die in diesem Artikel vorgestellte Version benötigen:

3D-Druck & individuelle Gestaltung

Erstellen Sie nun die Modelle für das Gehäuse, die individuellen Tastenkappen und die Drehknöpfe in einer 3D-Software wie Fusion. Die fertigen Dateien für dieses Projekt können Sie herunterladen von Printables.

Importieren Sie die Dateien in PrusaSlicer. Für ein klares, elegantes Erscheinungsbild können Sie den Korpus einfarbig mit Prusament Woodfill Linden Light drucken. Da der Fantasie jedoch keine Grenzen gesetzt sind, können Sie auch farbenfrohe Varianten erstellen – perfekt für ein Kinderzimmer, beispielsweise im Avengers-Stil. Fügen Sie anschließend SVG-Modifizierer mit einfachen Symbolen zu den Tastenkappen und dem Drehknopf hinzu indem Sie in PrusaSlicer mit der rechten Maustaste auf das Modell klicken und Modifikator hinzufügen > SVG auswählen. Wenn Sie eine ausführlichere Anleitung zur Anwendung von SVG-Modifikatoren wünschen, lesen Sie unseren Artikel über selbstgemachtes sensorisches Spielzubehör. Die Wahl eines dunkleren Prusament Chocolate Brown Woodfill für die Tasten und die Verwendung desselben hellen Linden Light für die Symbole sorgt für einen sehr schönen Kontrast. Dank des Multimaterial-Drucks auf einem Drucker wie dem Prusa CORE One+ INDX oder des Original Prusa XL ist das Ergebnis unglaublich präzise, ohne Farbverunreinigungen und mit einem absoluten Minimum an Abfall. Am besten drucken Sie die Tastenkappen mit der Vorderseite nach unten auf dem Druckbett. Auf dem Bild unten sind sie nur zur Veranschaulichung der SVG-Designs mit der Vorderseite nach oben gedreht. Sobald alle Teile gedruckt sind, geht es an die Montage.

Montage & Verkabelung

Installieren Sie zunächst die mechanischen Tastaturschalter, indem Sie diese einfach durch die Öffnungen im Gehäuse drücken, bis sie einrasten. Setzen Sie anschließend das Display, den Drehgeber und den ESP32 ein und stecken Sie dessen USB-C-Anschluss so in die vorbereitete Öffnung an der Seite des Gehäuses, dass er nach außen zeigt. Während das Display und der Encoder von selbst recht fest sitzen, erfordert die Befestigung des ESP32 etwas mehr Sorgfalt. Ich habe einen einfachen gedruckten Abstandhalter verwendet, den Sie einfach zwischen die Gehäusewand und die Platine schieben, um diese zu fixieren, damit der ESP32 beim Anschließen des USB-C-Kabels nicht nach hinten gedrückt wird.

Die Konfiguration belegt insgesamt elf Pins: sechs Schalter, den Encoder (2 Pins für die Drehung, 1 für den Schalter) und das I2C-Display (2 Pins für Daten/Takt). Dies entspricht genau der Anzahl der auf meiner ESP32-Platine verfügbaren digitalen Eingänge. Nachstehend finden Sie den Schaltplan, der in Wokwi erstellt wurde, einem großartigen kostenlosen Simulator, der direkt in Ihrem Browser läuft. Wokwi verfügt auch über einen integrierten Simulator, sodass Sie alle Komponenten anschließen und Testcode schreiben können, um sicherzustellen, dass Ihre Verdrahtung korrekt ist, bevor Sie die physische Einheit zusammenbauen.

Seien Sie vorsichtig, wenn Sie sich die Platine ansehen: Die auf der Leiterplatte gedruckte Beschriftung (D0–D10) weicht fast immer von den im Code verwendeten internen Registern (GPIO) ab. Hier ist die Hardware-Zuordnung für meinen ESP32:

5V / 5V0 – VCC (Gemeinsame Stromleitung für das OLED-Display und den Drehgeber)

GND – GND (Gemeinsamer Anschluss für alle Komponenten und mechanische Tasten)

D0 (Interner GPIO 2) – Taste 1

D1 (Interner GPIO 3) – Taste 2

D2 (Interner GPIO 4) – Taste 3

D3 (Interner GPIO 5) – Taste 4

D4 (Interner GPIO 6) – OLED SDA (Datenleitung)

D5 (Interner GPIO 7) – OLED SCL (Taktleitung)

D6 (Interner GPIO 21) – Encoder CLK (Drehungs-Pin A)

D7 (Interner GPIO 20) – Encoder DT (Drehungs-Pin B)

D8 (Interner GPIO 8) – Encoder SW (Integrierte Encoder-Taste)

D9 (Interner GPIO 9) – Taste 5

D10 (Interner GPIO 10) – Taste 6

Für erste Tests können Sie alles wie ich mit Dupont-Steckern verbinden. Allerdings ist der Platz im Gehäuse begrenzt, und diese Stecker sind für den täglichen Gebrauch nicht sicher genug. Um 100-prozentige Zuverlässigkeit und einen sauberen Einbau zu gewährleisten, empfehle ich dringend, alle Verbindungen festzulöten.

Softwarekonfiguration (ESPHome)

Nun, da alles verkabelt ist, ist es Zeit für (Vibe-)Coding 😎! Das Verbinden des ESP32 mit einem PC oder Mac ist ganz einfach. Schließen Sie es einfach mit einem USB-C-Kabel an Ihren Computer an, laden Sie die erforderlichen Tools herunter und laden Sie den Code über das Terminal auf das Board hoch. Auf einem Mac können Sie Python und dessen ESPHome-Paket verwenden, das über den Python-Paketmanager pip mit dem Befehl pip3 install esphome installiert wird.

Sobald die Installation abgeschlossen ist, erstellen Sie zwei YAML-Dateien: keyboard.yaml und secrets.yaml. Die Datei keyboard.yaml enthält den gesamten Code für den ESP32, und die Datei secrets.yaml speichert Ihre WLAN-Zugangsdaten sicher. Sie benötigen außerdem eine Schriftartdatei. In diesem Projekt habe ich die Schriftart Nunito aus der Google Fonts-Bibliothek verwendet. Sie finden sie hier: https://fonts.google.com/specimen/Nunito. Laden Sie die Datei herunter, entpacken Sie sie, legen Sie die Schriftart in der regulären Schriftstärke (Nunito-Regular.ttf) im selben Ordner wie die anderen Dateien ab und benennen Sie sie in font.ttf um und legen Sie sie im selben Ordner wie die anderen Dateien ab.

Hinweis: Dieser Code wurde speziell für das Seeed Studio XIAO ESP32-C3 geschrieben. Wenn Sie ein anderes ESP32-Board verwenden, müssen Sie den Parameter board: sowie die GPIO-Pin-Zuordnungen an Ihre jeweilige Hardware anpassen. Wenn Sie sich nicht sicher sind, wie das geht, zögern Sie nicht, Ihren bevorzugten KI-Assistenten um Hilfe zu bitten! 🙂

Hier ist die vollständige Datei keyboard.yaml. Lassen Sie sich nicht von den langen Abschnitten abschrecken, die mit lambda: gekennzeichnet sind. Diese kümmern sich um die Hintergrundlogik, wie beispielsweise die Umwandlung von Rohdaten zur Helligkeit in saubere Prozentwerte (%) und die Formatierung des Textes auf dem OLED-Bildschirm.

esphome:
  name: keyboard
  on_boot:
    priority: -100
    then:
      - sensor.rotary_encoder.set_value:
          id: rotary_knob
          value: 10
      - sensor.template.publish:
          id: ha_knob
          state: 10
      - binary_sensor.template.publish:
          id: ha_service_mode
          state: false

esp32:
  board: seeed_xiao_esp32c3

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password

captive_portal:

api:
  on_client_connected:
    - lambda: |-
        id(ha_service_mode).publish_state(id(service_mode));
        id(ha_active_key_sensor).publish_state(id(active_text));
  services:
    - service: set_display_text
      variables:
        new_text: string
      then:
        - lambda: |-
            id(active_text) = new_text;
            id(ha_active_key_sensor).publish_state(new_text);
            id(oled_display).update();

logger:
  baud_rate: 115200

i2c:
  sda: 6
  scl: 7

globals:
  - id: active_text
    type: std::string
    initial_value: '"OFF"'
  - id: service_mode
    type: bool
    initial_value: 'false'
  - id: saved_light_steps
    type: int
    initial_value: '10'
  - id: display_steps
    type: int
    initial_value: '10'

script:
  - id: block_feedback_script
    mode: restart
    then:
      - delay: 800ms

font:
  - file: "font.ttf"
    id: font_large
    size: 14
  - file: "font.ttf"
    id: font_sub
    size: 10

text_sensor:
  - platform: template
    name: "Active Key"
    id: ha_active_key_sensor

sensor:
  - platform: template
    name: "Rotary Knob"
    id: ha_knob

  - platform: rotary_encoder
    id: rotary_knob
    pin_a: 21
    pin_b: 20
    min_value: 0
    max_value: 10
    resolution: 2
    on_value:
      then:
        - lambda: |-
            if (isnan(x)) return;
            if (id(service_mode)) {
              if (x == 0) id(rotary_knob).set_value(1);
              id(oled_display).set_contrast(id(rotary_knob).state / 10.0);
            } else {
              if (x == 0 and id(ha_light_state).state) id(rotary_knob).set_value(1);
              id(block_feedback_script).execute();
              id(ha_knob).publish_state(id(rotary_knob).state);
            }
        - component.update: oled_display

  - platform: homeassistant
    id: ha_light_brightness
    entity_id: light.office
    attribute: brightness
    on_value:
      then:
        - lambda: |-
            if (not id(service_mode) and not id(block_feedback_script).is_running() and not isnan(x)) {
              int steps = round((x / 255.0) * 10.0);
              id(rotary_knob).set_value(steps);
              id(ha_knob).publish_state(steps);
            }
        - component.update: oled_display

binary_sensor:
  - platform: template
    name: "Service Mode"
    id: ha_service_mode

  - platform: status
    id: ha_connection_status

  - platform: homeassistant
    id: ha_light_state
    entity_id: light.office
    filters:
      - delayed_off: 500ms
    on_state:
      then:
        - lambda: |-
            if (not x) {
              if (not id(service_mode)) {
                id(rotary_knob).set_value(0);
                id(ha_knob).publish_state(0);
              } else {
                id(saved_light_steps) = 0;
              }
              id(active_text) = "OFF";
              id(ha_active_key_sensor).publish_state("OFF");
              id(oled_display).update();
            }

  - platform: gpio
    name: "Encoder Press"
    pin: {number: 8, mode: INPUT_PULLUP, inverted: true}
    on_press:
      then:
        - lambda: |-
            float current_state = isnan(id(rotary_knob).state) ? 10.0 : id(rotary_knob).state;
            if (not id(service_mode)) {
              id(saved_light_steps) = (int)current_state;
              id(service_mode) = true;
              id(rotary_knob).set_value(id(display_steps));
              id(ha_service_mode).publish_state(true);
            } else {
              id(display_steps) = (int)current_state;
              id(service_mode) = false;
              id(rotary_knob).set_value(id(saved_light_steps));
              id(ha_knob).publish_state(id(saved_light_steps));
              id(ha_service_mode).publish_state(false);
            }
        - component.update: oled_display

  - platform: gpio
    name: "Key 1"
    pin: {number: 2, mode: INPUT_PULLUP, inverted: true}
  - platform: gpio
    name: "Key 2"
    pin: {number: 3, mode: INPUT_PULLUP, inverted: true}
  - platform: gpio
    name: "Key 3"
    pin: {number: 4, mode: INPUT_PULLUP, inverted: true}
  - platform: gpio
    name: "Key 4"
    pin: {number: 5, mode: INPUT_PULLUP, inverted: true}
  - platform: gpio
    name: "Key 5"
    pin: {number: 9, mode: INPUT_PULLUP, inverted: true}
  - platform: gpio
    name: "Key 6"
    pin: {number: 10, mode: INPUT_PULLUP, inverted: true}

display:
  - platform: ssd1306_i2c
    id: oled_display
    model: "SSD1306 128x32"
    address: 0x3C
    rotation: 180
    lambda: |-
      if (id(service_mode)) {
        it.print(0, 0, id(font_large), "DISPLAY");
      } else {
        it.print(0, 0, id(font_large), id(active_text).c_str());
      }
      
      if (id(ha_connection_status).state) {
        it.print(82, 0, id(font_sub), "HA: OK");
      } else {
        it.print(82, 0, id(font_sub), "HA: --");
      }
      
      it.printf(0, 19, id(font_sub), "Int: %.0f%%", isnan(id(rotary_knob).state) ? 0.0 : id(rotary_knob).state * 10.0);
      
      if (wifi::global_wifi_component->is_connected()) {
        it.print(75, 19, id(font_sub), "Wi-Fi: OK");
      } else {
        it.print(75, 19, id(font_sub), "Wi-Fi: --");
      }

Das WLAN-Passwort befindet sich in einer separaten Datei secrets.yaml. Erstellen Sie diese Datei und passen Sie sie mit Ihren eigenen Zugangsdaten an:

wifi_ssid: "mein_wi-fi"
wifi_password: "mein_geheimes_passwort"

Nun können Sie den Code kompilieren und mit dem Befehl python3 -m esphome run keyboard.yaml auf Ihren ESP32 hochladen. Bitte beachten Sie, dass Sie diesen Befehl aus dem Ordner ausführen müssen, in dem sich Ihre YAML-Datei befindet. Wenn Sie im Terminal dazu aufgefordert werden, geben Sie die Nummer des angeschlossenen USB-Anschlusses ein und drücken Sie die Eingabetaste.

Wenn alles erfolgreich hochgeladen wurde, sollten Sie im Terminal das Kommunikationsprotokoll zwischen Ihrem Computer und dem ESP32 sehen, und das Display sollte sich einschalten.

Das Display zeigt unter anderem auch Informationen zum WLAN-Verbindungsstatus an, der nach einigen Sekunden „OK“ anzeigen sollte. Außerdem sehen Sie auf dem Display eine Zeile mit „HA“, die den Verbindungsstatus zu Home Assistant angibt. Über diesen Status müssen Sie sich im Moment keine Gedanken machen. Sobald wir alles in HA konfiguriert haben, sollte dort ebenfalls „OK“ angezeigt werden.

Wenn Sie die Protokolle sehen und das Display die Informationen anzeigt, haben Sie den ESP32 erfolgreich geflasht und können mit der Home Assistant-Konfiguration fortfahren. Sie können das ESP32 an einen USB-Anschluss Ihres Computers angeschlossen lassen oder ein beliebiges handelsübliches 5-V-USB-Netzteil verwenden, um das Macropad mit Strom zu versorgen.

Home Assistant-Einrichtung

1. Hinzufügen des ESP32 zu Home Assistant

Dank der nativen ESPHome-Integration sollte Home Assistant Ihr neues Macropad automatisch erkennen.

• Navigieren Sie in Ihrem Home Assistant-Dashboard zu Einstellungen > Geräte & Dienste.
• Sehen Sie oben auf der Registerkarte Integrationen nach. Dort sollten Sie ein neu erkanntes ESPHome-Gerät mit dem Namen keyboard sehen.
• Klicken Sie auf Konfigurieren und folgen Sie den Anweisungen auf dem Bildschirm, um es zu Ihrer Konfiguration hinzuzufügen.
• Hinweis: Falls es nicht automatisch angezeigt wird, klicken Sie unten rechts auf Integration hinzufügen, suchen Sie nach ESPHome und geben Sie die lokale IP-Adresse Ihres ESP32 ein.

Sobald es hinzugefügt wurde, lädt Home Assistant automatisch alle Ihre mechanischen Tasten, den Drehgeber und den Servicemodus-Schalter.

2. Erstellen des „Light Group Helper“

Um dieses Projekt elegant und universell zu halten, möchten wir vermeiden, bestimmte physische Smart-Glühbirnen direkt in den Code festzuschreiben. Erstellen Sie stattdessen einen Light Group-Helper. Auf diese Weise müssen Sie bei einem Austausch Ihrer Glühbirnen lediglich diese Gruppe aktualisieren, und Ihre Automatisierung bleibt vollständig unberührt.

• Gehen Sie zu Einstellungen > Geräte & Dienste und klicken Sie oben auf die Registerkarte Helfer.
• Klicken Sie unten rechts auf + Helfer erstellen.
• Scrollen Sie nach unten, wählen Sie Gruppe und dann Leuchtengruppe.
• Benennen Sie den Helfer Office (dadurch wird automatisch die erforderliche Entitäts-ID generiert: light.office).
• Wählen Sie unter Mitglieder die tatsächlichen physischen Smart-Leuchten aus, die das Macropad steuern soll.
• Klicken Sie auf Übermitteln / Erstellen.

Nachdem das Macropad verbunden und unsere Leuchtengruppe eingerichtet ist, können wir nun alles mit unserem Master-Automatisierungsskript verknüpfen.

• Gehen Sie zu Einstellungen > Automatisierungen & Szenen und klicken Sie auf Automatisierung erstellen.
• Wählen Sie Neue Automatisierung erstellen, klicken Sie dann auf die drei Punkte in der oberen rechten Ecke und wählen Sie In YAML bearbeiten.
• Löschen Sie den Standardcode, fügen Sie das untenstehende Skript ein und klicken Sie auf Speichern.

Für diese Anleitung habe ich die sechs mechanischen Tasten so belegt, dass sie einfache Farbszenen (Blau, Grün, Rot usw.) aktivieren; Sie können diese jedoch so anpassen, dass sie beliebige Szenen auslösen, egal ob einfach oder komplex.

alias: Light Office - Master Control
description: Master Control for Macropad
triggers:
  - entity_id: binary_sensor.keyboard_key_1
    to: "on"
    id: press_k1
    trigger: state
  - entity_id: binary_sensor.keyboard_key_2
    to: "on"
    id: press_k2
    trigger: state
  - entity_id: binary_sensor.keyboard_key_3
    to: "on"
    id: press_k3
    trigger: state
  - entity_id: binary_sensor.keyboard_key_4
    to: "on"
    id: press_k4
    trigger: state
  - entity_id: binary_sensor.keyboard_key_5
    to: "on"
    id: press_k5
    trigger: state
  - entity_id: binary_sensor.keyboard_key_6
    to: "on"
    id: press_k6
    trigger: state
  - entity_id: sensor.keyboard_rotary_knob
    id: knob_rotation
    trigger: state
conditions:
  - condition: state
    entity_id: binary_sensor.keyboard_service_mode
    state: "off"
actions:
  - choose:
      - conditions:
          - condition: trigger
            id: knob_rotation
        sequence:
          - action: light.turn_on
            metadata: {}
            target:
              entity_id: light.office
            data:
              brightness_pct: "{{ (trigger.to_state.state | int(10)) * 10 }}"
      - conditions:
          - condition: trigger
            id: press_k1
        sequence:
          - choose:
              - conditions:
                  - condition: state
                    entity_id: sensor.keyboard_active_key
                    state: Blue
                sequence:
                  - action: light.turn_off
                    target:
                      entity_id: light.office
            default:
              - action: light.turn_on
                target:
                  entity_id: light.office
                data:
                  brightness_pct: 100
                  rgb_color:
                    - 4
                    - 51
                    - 255
              - action: esphome.keyboard_set_display_text
                data:
                  new_text: Blue
      - conditions:
          - condition: trigger
            id: press_k2
        sequence:
          - choose:
              - conditions:
                  - condition: state
                    entity_id: sensor.keyboard_active_key
                    state: Green
                sequence:
                  - action: light.turn_off
                    target:
                      entity_id: light.office
            default:
              - action: light.turn_on
                target:
                  entity_id: light.office
                data:
                  brightness_pct: 100
                  rgb_color:
                    - 0
                    - 249
                    - 0
              - action: esphome.keyboard_set_display_text
                data:
                  new_text: Green
      - conditions:
          - condition: trigger
            id: press_k3
        sequence:
          - choose:
              - conditions:
                  - condition: state
                    entity_id: sensor.keyboard_active_key
                    state: Red
                sequence:
                  - action: light.turn_off
                    target:
                      entity_id: light.office
            default:
              - action: light.turn_on
                target:
                  entity_id: light.office
                data:
                  brightness_pct: 100
                  rgb_color:
                    - 255
                    - 0
                    - 0
              - action: esphome.keyboard_set_display_text
                data:
                  new_text: Red
      - conditions:
          - condition: trigger
            id: press_k4
        sequence:
          - choose:
              - conditions:
                  - condition: state
                    entity_id: sensor.keyboard_active_key
                    state: Yellow
                sequence:
                  - action: light.turn_off
                    target:
                      entity_id: light.office
            default:
              - action: light.turn_on
                target:
                  entity_id: light.office
                data:
                  brightness_pct: 100
                  rgb_color:
                    - 255
                    - 255
                    - 0
              - action: esphome.keyboard_set_display_text
                data:
                  new_text: Yellow
      - conditions:
          - condition: trigger
            id: press_k5
        sequence:
          - choose:
              - conditions:
                  - condition: state
                    entity_id: sensor.keyboard_active_key
                    state: Purple
                sequence:
                  - action: light.turn_off
                    target:
                      entity_id: light.office
            default:
              - action: light.turn_on
                target:
                  entity_id: light.office
                data:
                  brightness_pct: 100
                  rgb_color:
                    - 255
                    - 0
                    - 255
              - action: esphome.keyboard_set_display_text
                data:
                  new_text: Purple
      - conditions:
          - condition: trigger
            id: press_k6
        sequence:
          - choose:
              - conditions:
                  - condition: state
                    entity_id: sensor.keyboard_active_key
                    state: White
                sequence:
                  - action: light.turn_off
                    target:
                      entity_id: light.office
            default:
              - action: light.turn_on
                target:
                  entity_id: light.office
                data:
                  brightness_pct: 100
                  rgb_color:
                    - 255
                    - 255
                    - 255
              - action: esphome.keyboard_set_display_text
                data:
                  new_text: White
mode: restart

Der YAML-Editor in Home Assistant sieht wie folgt aus:

Testen und Fazit

Nachdem alles hochgeladen ist, ist es an der Zeit, das Macropad zu testen. Drücken Sie eine Taste, und die Beleuchtungsszene sollte sich sofort ändern. Drehen Sie den Drehgeber, und die Lichtintensität ändert sich. Das OLED-Display sollte zudem die aktuell ausgewählte Szene korrekt anzeigen.

Wenn alles einwandfrei funktioniert, müssen Sie nur noch die untere Abdeckung drucken und einrasten lassen. Dank einer Reibungsverbindung sitzt sie sicher, ganz ohne Kleber oder Schrauben. Da ich meine Testversion mit sperrigen Dupont-Steckern verkabelt habe, benötigte ich im Inneren etwas mehr Freiraum, weshalb ich ein etwas höheres Unterteil angefertigt habe. Positiv gesehen habe ich dies genutzt, um erneut verschiedene Prusament Woodfill-Materialien zu mischen und so einen schönen Übergangsstreifen zu erzeugen. Wenn Sie sich entscheiden, Ihre Komponenten zu löten, können Sie die Datei für die Bodenabdeckung verschlanken, um die Höhe des Macropads deutlich zu reduzieren.

Obwohl ich dieses Macropad nur zur Beleuchtungssteuerung nutze, können Sie es auf jede beliebige Smart-Home-Funktion abbilden. Da Home Assistant die Logik übernimmt, kann ein Tastendruck oder eine Drehung des Drehgebers Jalousien verstellen, einen Staubsaugerroboter starten oder eine Spotify-Automatisierung auslösen, um Ihre Gäste zu „Rickrollen“. Der Fantasie sind keine Grenzen gesetzt!

Sobald Sie Ihr erstes Projekt dieser Art umgesetzt haben, fällt es schwer, nicht im ganzen Haus nach weiteren Stellen Ausschau zu halten, an denen ein 3D-Drucker und etwas Elektronik helfen können.

Viel Spaß beim Drucken!