You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 

185 rivejä
6.9 KiB

"""
`snakeswitch`
=============
CircuitPython implementation of a foot-switch and NeoTrellis device for
triggering keyboard events.
See code.py for a demo of the usage.
* Author(s): Brennen Bearnes
"""
# pylint: disable=import-error
import time
import board
import digitalio
import busio
import neopixel
from adafruit_hid.keyboard import Keyboard
from adafruit_neotrellis.neotrellis import NeoTrellis
# pylint: enable=import-error
COLOR_ACTIVE_LAYOUT = (40, 20, 0)
COLOR_INACTIVE_LAYOUT = (5, 0, 5)
COLOR_PRESSED = (80, 40, 0)
COLOR_TRIGGER = (0, 5, 0)
COLOR_UNDEFINED = (0, 0, 0)
BOUNCE_SECS = 0.250
NEOTRELLIS_COUNT = 16
def get_keys_for_switch(switch, current_layouts):
"""
Return a list of keycodes that are triggered by a switch in the
given set of layouts.
"""
keys = []
for layout in current_layouts:
if switch in layout:
if isinstance(layout[switch], tuple):
keys.extend(layout[switch])
else:
keys.append(layout[switch])
return keys
def diag(*message):
"""Print a diagnostic message to the console."""
print(time.monotonic(), message)
class SnakeSwitch:
"""
Class modeling a SnakeSwitch.
Expects a tuple listing the pins that switches are connected to,
and a dictionary of layouts - see switch_config.py for a sample
configuration.
"""
def __init__(self, switch_pins, layouts):
i2c_bus = busio.I2C(board.SCL, board.SDA)
self.trellis = NeoTrellis(i2c_bus)
self.kbd = Keyboard()
diag('initializing pins', switch_pins)
self.switch_inputs = tuple(digitalio.DigitalInOut(pin) for pin in switch_pins)
for switch_input in self.switch_inputs:
switch_input.switch_to_input(pull=digitalio.Pull.UP)
self.layouts = layouts
self.active_layouts = {}
self.active_switches = {}
for i in range(NEOTRELLIS_COUNT):
# Mark any mapped to each button as currently inactive:
self.active_layouts[i] = False
# Activate rising / falling edge events on all keys, set up callback:
self.trellis.activate_key(i, NeoTrellis.EDGE_RISING)
self.trellis.activate_key(i, NeoTrellis.EDGE_FALLING)
self.trellis.callbacks[i] = self.handle_neotrellis_event
# Activate first defined layout that isn't just a key trigger:
for layout_id, layout in self.layouts.items():
if isinstance(layout, dict):
self.toggle_layout(layout_id)
break
self.paint_trellis()
# Turn off NeoPixel on the Feather M4:
onboard_pixel = neopixel.NeoPixel(board.NEOPIXEL, 1)
onboard_pixel[0] = (0, 0, 0)
def handle_neotrellis_event(self, event):
"""A callback for handling NeoTrelllis rising/falling edges."""
if event.edge == NeoTrellis.EDGE_RISING:
# Highlight the currently pressed button:
self.trellis.pixels[event.number] = COLOR_PRESSED
elif event.edge == NeoTrellis.EDGE_FALLING:
# On release, activate a button if it has a defined layout (or fire
# any defined key events):
if event.number in self.layouts:
action_for_button = self.layouts[event.number]
if isinstance(action_for_button, int):
# It's a key code, press it:
diag("pressing and releasing keycode: ", action_for_button)
self.kbd.press(self.layouts[event.number])
self.kbd.release_all()
elif isinstance(action_for_button, tuple):
# It's a tuple with multiple key codes - fire them all:
diag("pressing and releasing keycode combo: ", action_for_button)
for k in action_for_button:
self.kbd.press(k)
self.kbd.release_all()
else:
# Toggle a layout:
self.toggle_layout(event.number)
self.paint_trellis()
def toggle_layout(self, layout_id):
"""Toggle the state of a given layout."""
diag('switching layout: ', layout_id)
self.active_layouts[layout_id] = not self.active_layouts[layout_id]
def paint_trellis(self):
"""Set state of trellis LEDs based on defined and active layouts."""
for layout_button, active in self.active_layouts.items():
if active:
# Layout is currently activated:
self.trellis.pixels[layout_button] = COLOR_ACTIVE_LAYOUT
elif layout_button in self.layouts:
if isinstance(self.layouts[layout_button], (tuple, int)):
# Button is actually a keycode or set of keycodes to fire on press:
self.trellis.pixels[layout_button] = COLOR_TRIGGER
else:
# Layout is defined, but deactivated:
self.trellis.pixels[layout_button] = COLOR_INACTIVE_LAYOUT
else:
# Layout isn't defined in the config file:
self.trellis.pixels[layout_button] = COLOR_UNDEFINED
def advance_frame(self):
"""
Advance the frame, synchronizing the trellis (which will call
handle_neotrellis_event() as necessary) and pressing / releasing
keys where appropriate for the currently pressed switch and
currently active layout.
"""
# Trellis sync may need to happen less frequently than this?
self.trellis.sync()
# Accumulate currently-active switch layouts:
current_layouts = [
self.layouts[layout] for layout, active
in self.active_layouts.items() if active
]
for switch, switch_input in enumerate(self.switch_inputs):
# If switch is un-pressed, it's pulled high. Make sure to release
# any keys attached to it and mark it non-active.
if switch_input.value:
if switch in self.active_switches and self.active_switches[switch]:
diag('marking switch', switch, ' inactive')
keys = get_keys_for_switch(switch, current_layouts)
for key in keys:
diag('release key:', key)
self.kbd.release(key)
self.active_switches[switch] = False
continue
if switch in self.active_switches and self.active_switches[switch]:
# If we're already marked active, do nothing.
continue
# If switch is pressed, it's pulled low. Debounce by waiting for bounce time:
time.sleep(BOUNCE_SECS)
diag('marking switch', switch, ' active')
self.active_switches[switch] = True
for key in get_keys_for_switch(switch, current_layouts):
diag('press key:', key)
self.kbd.press(key)