for layer in layers.keys():
keys[layer].led_off()
# Give some visual feedback for the modifier key
keys[0].set_led(0, 255, 25)
# Loop through all of the keys in the layer and if they're pressed, get the
# key code from the layer's key map
for k in layers[current_layer].keys():
if keys[k].pressed:
key_press = layers[current_layer][k]
# If the key hasn't just fired (prevents refiring)
if not fired:
fired = True
# Send the right sort of key press and set debounce for each
# layer accordingly (layer 2 needs a long debounce)
if current_layer == 1:
debounce = short_debounce
keyboard.send(key_press)
elif current_layer == 2:
debounce = long_debounce
layout.write(key_press)
elif current_layer == 3:
debounce = short_debounce
consumer_control.send(key_press)
# If enough time has passed, reset the fired variable
if fired and time.monotonic() - keybow.time_of_last_press > debounce:
fired = False
# SPDX-FileCopyrightText: 2018 Anne Barela for Adafruit Industries
#
# SPDX-License-Identifier: MIT
import usb_hid
from adafruit_circuitplayground.express import cpx
from adafruit_hid.consumer_control import ConsumerControl
from adafruit_hid.consumer_control_code import ConsumerControlCode
cc = ConsumerControl(usb_hid.devices)
while True:
if cpx.button_a:
cc.send(ConsumerControlCode.VOLUME_INCREMENT)
while cpx.button_a:
pass
if cpx.button_b:
cc.send(ConsumerControlCode.VOLUME_DECREMENT)
while cpx.button_b:
pass
_cur_actions = [_cur_actions]
# loop over the actions
for _action in _cur_actions:
# HID keyboard keys
if _action[0] == KEY:
kbd.press(*_action[1])
kbd.release(*_action[1])
# String to write from layout
elif _action[0] == STRING:
kbd_layout.write(_action[1])
# Consumer control code
elif _action[0] == MEDIA:
cc.send(_action[1])
# Key press
elif _action[0] == KEY_PRESS:
kbd.press(*_action[1])
# Key release
elif _action[0] == KEY_RELEASE:
kbd.release(*_action[1])
# Change Layer
elif _action[0] == CHANGE_LAYER:
if isinstance(
_action[1], int
) and 0 <= _action[1] < len(
touch_deck_config["layers"]
from adafruit_hid.keycode import Keycode
from adafruit_hid.consumer_control import ConsumerControl
from adafruit_hid.consumer_control_code import ConsumerControlCode
time.sleep(1) # Sleep for a bit to avoid a race condition on some systems
control_key = Keycode.SHIFT
cc = ConsumerControl(usb_hid.devices)
cols = [digitalio.DigitalInOut(x) for x in (board.D11, board.D12, board.D13)]
rows = [digitalio.DigitalInOut(x) for x in (board.D9, board.D10)]
keys = (
(0,1,2),
(3,4,5),
)
keypad = adafruit_matrixkeypad.Matrix_Keypad(rows, cols, keys)
KEYS = [
ConsumerControlCode.SCAN_NEXT_TRACK,
ConsumerControlCode.VOLUME_INCREMENT,
ConsumerControlCode.PLAY_PAUSE,
ConsumerControlCode.SCAN_PREVIOUS_TRACK,
ConsumerControlCode.VOLUME_DECREMENT,
ConsumerControlCode.MUTE,
]
while True:
keys = keypad.pressed_keys
if keys:
for key in keys:
cc.send(KEYS[key])
time.sleep(0.1)
delta = pos - last_pos
last_pos = pos
direction = 0
if delta > 0:
command = ConsumerControlCode.VOLUME_INCREMENT
direction = -1
elif delta < 0:
command = ConsumerControlCode.VOLUME_DECREMENT
direction = 1
if direction:
muted = False
for _ in range(abs(delta)):
cc.send(command)
# spin neopixel LED around in the correct direction!
dot_location = (dot_location + direction) % len(cp.pixels)
draw()
if cp.button_b and not button_b_pressed:
if not muted:
print("Muting")
cc.send(ConsumerControlCode.MUTE)
muted = True
else:
print("Unmuting")
cc.send(ConsumerControlCode.MUTE)
muted = False
draw()
# while not button_B.value: # debounce
(r, g, b) = (0, int(pos * 3), int(255 - pos * 3))
return (r, g, b)
last_encoder_val = encoder.position
ring_pos = 0
rainbow_pos = 0
while True:
diff = last_encoder_val - encoder.position # encoder clicks since last read
last_encoder_val = encoder.position
ring_pos = (ring_pos + diff) % len(ring) # position on LED ring
hue = colorwheel(encoder.position * 4 % 255) # fun hue change based on pos
if button.value == False: # button pressed
cc.send(ConsumerControlCode.MUTE) # toggle mute
while not button.value: # wait for release
time.sleep(0.05)
for i in range(len(ring)): # spin the rainbow while held
pixel_index = (i * 256 // len(ring)) + rainbow_pos
ring[i] = colorwheel(pixel_index & 255)
ring.show()
rainbow_pos = (rainbow_pos + 1) % 256
else:
if diff > 0:
for i in range(diff):
cc.send(ConsumerControlCode.VOLUME_DECREMENT)
time.sleep(0.01)
elif diff < 0:
for i in range(-diff):
cc.send(ConsumerControlCode.VOLUME_INCREMENT)
while True:
pressed = set(trellis.pressed_keys)
now = time.monotonic()
sleep_time = now - last_press
sleeping = sleep_time > TIMEOUT
for down in pressed - current_press:
if down in keymap and not sleeping:
print("down", down)
# Lower the brightness so that we don't draw too much current when we turn all of
# the LEDs on.
trellis.pixels.brightness = 0.2
trellis.pixels.fill(keymap[down][0])
if keymap[down][1] == KEY:
kbd.press(*keymap[down][2]) if type(keymap[down][2]) == tuple else kbd.press(keymap[down][2])
else:
cc.send(keymap[down][2])
# else if the entry starts with 'l' for layout.write
last_press = now
for up in current_press - pressed:
if up in keymap:
print("up", up)
if keymap[up][1] == KEY:
if type(keymap[down][2]) == tuple:
kbd.release(*keymap[down][2])
else:
kbd.release(keymap[down][2])
# Reset the LEDs when there was something previously pressed (current_press) but nothing now
# (pressed).
if not pressed and current_press:
trellis.pixels.brightness = 1