keybow2040/code/code_eigenbau.py

import board
import time
from keybow2040 import Keybow2040

import usb_hid
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS
from adafruit_hid.keycode import Keycode

from adafruit_hid.consumer_control import ConsumerControl
from adafruit_hid.consumer_control_code import ConsumerControlCode

# Set up Keybow
i2c = board.I2C()
keybow = Keybow2040(i2c)
keys = keybow.keys

# Set up the keyboard and layout
keyboard = Keyboard(usb_hid.devices)
layout = KeyboardLayoutUS(keyboard)

# Set up consumer control (used to send media key presses)
consumer_control = ConsumerControl(usb_hid.devices)


# Denfiniere Layer als Dictionary
layer_0 =     {}
layer_1 =     {4: Keycode.PERIOD,
               5: Keycode.ONE,
               6: Keycode.FOUR,
               7: Keycode.SEVEN,
               8: Keycode.ZERO,
               9: Keycode.TWO,
               10: Keycode.FIVE,
               11: Keycode.EIGHT,
               12: Keycode.ENTER,
               13: Keycode.THREE,
               14: Keycode.SIX,
               15: Keycode.NINE}
layer_2 =     {4: "Mit freundlichen Gruessen\nMichael Grote "
                }
layer_3 =     {6: ConsumerControlCode.VOLUME_DECREMENT,
               7: ConsumerControlCode.SCAN_PREVIOUS_TRACK,
               10: ConsumerControlCode.MUTE,
               11: ConsumerControlCode.PLAY_PAUSE,
               14: ConsumerControlCode.VOLUME_INCREMENT,
               15: ConsumerControlCode.SCAN_NEXT_TRACK}
layers =      {0: layer_0,
               1: layer_1,
               2: layer_2,
               3: layer_3}

# welches ist der aktive Layer
current_layer = 1
# weclche Tasten dienen nicht der Layer-Auswahl
nutzbare_tasten = range(4,16) #zählt von 1-16; nicht 0-15
# Debounce-Werte
short_debounce = 0.03
long_debounce = 0.15
debounce = short_debounce
taste_ausgelöst = False

# Farben der Layer als Dictionary
# https://gist.github.com/ninrod/b0f86d77ebadaccf7d9d4431dd8e2983
# https://colorhunt.co/palette/f7fd04f9b208f98404fc5404
colours = {0: (247, 253, 4),
           1: (249, 178, 8),
           2: (249, 132, 4),
           3: (252, 84, 4),
           4: (255,155,255)} # weiß
# setze farben auf layer keys und den nutzbaren tasten nach dem start
keybow.keys[0].set_led(*colours[0])
keybow.keys[1].set_led(*colours[1])
keybow.keys[2].set_led(*colours[2])
keybow.keys[3].set_led(*colours[3])

while True:
    # Always remember to call keybow.update()!
    keybow.update()
    # wenn layer-auswahl key gedrückt dann..
    if keys[0].pressed:
        # setze ALLE nutzbaren tasten auf weiß
        for k in nutzbare_tasten:
            keys[k].set_led(*colours[4])
        # setze current layer
        current_layer = 0
    elif keys[1].pressed:
        for k in nutzbare_tasten:
            keys[k].set_led(*colours[4])
        current_layer = 1
    elif keys[2].pressed:
        for k in nutzbare_tasten:
            keys[k].set_led(*colours[4])
        current_layer = 2
    elif keys[3].pressed:
        for k in nutzbare_tasten:
            keys[k].set_led(*colours[4])
        current_layer = 3
    # färbe zum layer gehörende tasten ein
    for b in layers[current_layer].keys():
        keys[b].set_led(*colours[current_layer])
    # "frage" alle tasten ab
    for taste in layers[current_layer].keys():
        # wenn gedrückt
        if keys[taste].pressed:

            # setze keycode
            key_press = layers[current_layer][taste]
            # prufe ob taste vor kurzem ausgelöst wurde
            if not taste_ausgelöst:
                taste_ausgelöst = True
                # prüfe layer wegen debounce und "sende"-art
                if current_layer == 0:
                    keyboard.send(key_press)
                elif current_layer == 1:
                    keyboard.send(key_press)
                elif current_layer == 2:
                    debounce = long_debounce
                    layout.write(key_press)
                elif current_layer == 3:
                    consumer_control.send(key_press)
    # hebe "debounce" auf
    if taste_ausgelöst and time.monotonic() - keybow.time_of_last_press > debounce:
        taste_ausgelöst = False