sporq/kmk_firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

@kdb424's Leader Mode work as a clean diff

Browse Source
This commit is contained in:
Josh Klar
2018-10-08 02:31:30 -07:00
parent 914b305fee
commit 8c9fc9db95
8 changed files with 205 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
kmk/common/consts.py
View File

@@ -143,3 +143,10 @@ class UnicodeModes:
LINUX = IBUS = 1
MACOS = OSX = RALT = 2
WINC = 3
class LeaderMode:
Default = 0
Default_Active = 1
Enter = 2
Enter_Active = 3

4
kmk/common/event_defs.py
View File

@@ -25,7 +25,6 @@ InitFirmware = namedtuple('InitFirmware', (
'row_pins',
'col_pins',
'diode_orientation',
'unicode_mode',
))
KeyUpDown = namedtuple('KeyUpDown', ('type', 'row', 'col'))
@@ -34,14 +33,13 @@ NewMatrix = namedtuple('NewMatrix', ('type', 'matrix'))
BareEvent = namedtuple('BareEvent', ('type',))
def init_firmware(keymap, row_pins, col_pins, diode_orientation, unicode_mode):
def init_firmware(keymap, row_pins, col_pins, diode_orientation):
return InitFirmware(
type=INIT_FIRMWARE_EVENT,
keymap=keymap,
row_pins=row_pins,
col_pins=col_pins,
diode_orientation=diode_orientation,
unicode_mode=unicode_mode,
)

40
kmk/common/internal_state.py
View File

@@ -2,7 +2,7 @@ import logging
import sys
from kmk.common import kmktime
from kmk.common.consts import DiodeOrientation, UnicodeModes
from kmk.common.consts import DiodeOrientation, LeaderMode, UnicodeModes
from kmk.common.event_defs import (HID_REPORT_EVENT, INIT_FIRMWARE_EVENT,
KEY_DOWN_EVENT, KEY_UP_EVENT,
KEYCODE_DOWN_EVENT, KEYCODE_UP_EVENT,
@@ -69,28 +69,30 @@ class InternalState:
keys_pressed = set()
pending_keys = set()
macro_pending = None
leader_pending = None
hid_pending = False
unicode_mode = UnicodeModes.NOOP
tap_time = 300
keymap = []
row_pins = []
col_pins = []
matrix = []
diode_orientation = DiodeOrientation.COLUMNS
leader_mode_history = []
active_layers = [0]
start_time = {
'lt': None,
'tg': None,
'tt': None,
}
tick_time = {
'lt': None,
'tg': None,
'tt': None,
'lm': None,
'leader': None,
}
_oldstates = []
def __init__(self, preserve_intermediate_states=False):
import kmk_keyboard_user
self.unicode_mode = getattr(kmk_keyboard_user, 'unicode_mode', UnicodeModes.NOOP)
self.tap_time = getattr(kmk_keyboard_user, 'tap_time', 300)
self.leader_mode = getattr(kmk_keyboard_user, 'leader_mode', LeaderMode.Enter)
self.LEADER_DICTIONARY = getattr(kmk_keyboard_user, 'LEADER_DICTIONARY', {})
self.preserve_intermediate_states = preserve_intermediate_states
def __enter__(self):
@@ -105,8 +107,8 @@ class InternalState:
'active_layers': self.active_layers,
'unicode_mode': self.unicode_mode,
'tap_time': self.tap_time,
'leader_mode_history': self.leader_mode_history,
'start_time': self.start_time,
'tick_time': self.tick_time,
}
if verbose:
@@ -196,18 +198,19 @@ def kmk_reducer(state=None, action=None, logger=None):
state.matrix = action.matrix
state.keys_pressed |= pressed
state.keys_pressed -= released
state.hid_pending = True
if state.leader_mode % 2 == 1:
state.hid_pending = False
else:
state.hid_pending = True
return state
if action.type == KEYCODE_UP_EVENT:
state.keys_pressed.discard(action.keycode)
state.hid_pending = True
return state
if action.type == KEYCODE_DOWN_EVENT:
state.keys_pressed.add(action.keycode)
state.hid_pending = True
return state
if action.type == INIT_FIRMWARE_EVENT:
@@ -216,7 +219,6 @@ def kmk_reducer(state=None, action=None, logger=None):
row_pins=action.row_pins,
col_pins=action.col_pins,
diode_orientation=action.diode_orientation,
unicode_mode=action.unicode_mode,
)
# HID events are non-mutating, used exclusively for listeners to know
@@ -224,7 +226,6 @@ def kmk_reducer(state=None, action=None, logger=None):
# into KEY_UP_EVENT and KEY_DOWN_EVENT, but for now it's nice to separate
# this out for debugging's sake.
if action.type == HID_REPORT_EVENT:
state.hid_pending = False
return state
if action.type == MACRO_COMPLETE_EVENT:
@@ -268,6 +269,8 @@ def process_internal_key_event(state, action_type, changed_key, logger=None):
return unicode_mode(state, action_type, changed_key, logger=logger)
elif changed_key.code == RawKeycodes.KC_MACRO:
return macro(state, action_type, changed_key, logger=logger)
elif changed_key.code == Keycodes.KMK.KC_LEAD.code:
return leader(state)
else:
return state
@@ -410,3 +413,12 @@ def macro(state, action_type, changed_key, logger):
return state
return state
def leader(state):
if state.leader_mode % 2 == 0:
state.keys_pressed.discard(Keycodes.KMK.KC_LEAD)
# All leader modes are one number higher when activating
state.leader_mode += 1
return state

74
kmk/common/leader_mode.py Normal file
View File

@@ -0,0 +1,74 @@
import logging
from kmk.common.keycodes import Keycodes
class LeaderHelper:
"""
Acts as a hid to absorb keypress, and perform macros when a timer
or enter key is pressed depending on the mode set.
"""
def __init__(self, store, log_level=logging.NOTSET):
self.logger = logging.getLogger(__name__)
self.logger.setLevel(log_level)
self.store = store
self.store.subscribe(
lambda state, action: self._subscription(state, action),
)
def _subscription(self, state, action):
"""
Subscribes to the state machine, and dispatches actions based
based on incoming keypresses, or when a timer runs out depending
on the mode.
:param state:
:param action:
:return state:
"""
if state.leader_mode % 2 == 1:
for key in state.keys_pressed:
if key == Keycodes.Common.KC_ENT:
# Process the action and remove the extra KC.ENT that was added to get here
state = process(state)
state.keys_pressed.discard(Keycodes.Common.KC_ENT)
return clean_exit(state)
elif key == Keycodes.Common.KC_ESC:
# Clean state and turn leader mode off.
return clean_exit(state)
elif key == Keycodes.KMK.KC_LEAD:
return state
else:
# Add key if not needing to escape
# This needs replaced later with a proper debounce
state.leader_mode_history.append(key)
return state.keys_pressed.discard(key)
return state
def clean_exit(state):
"""
Cleans up the state and hands the HID control back.
:param state:
:return state:
"""
state.leader_mode_history = []
state.leader_mode -= 1
state.keys_pressed.discard(Keycodes.Common.KC_ESC)
return state
def process(state):
"""
Checks if there are iny matching sequences of keys, and
performs the macro specified by the user.
:param state:
:param leader_dictionary:
:return state:
"""
lmh = tuple(state.leader_mode_history)
for k, v in state.LEADER_DICTIONARY.items():
if k == lmh:
state.macro_pending = v.keydown
return state

28
kmk/entrypoints/handwire/pyboard.py
View File

@@ -1,19 +1,29 @@
import sys
from logging import DEBUG
from kmk.common.consts import UnicodeModes
import gc
from kmk.common.leader_mode import LeaderHelper
from kmk.firmware import Firmware
from kmk.micropython.matrix import MatrixScanner
from kmk.micropython.pyb_hid import HIDHelper
def main():
from kmk_keyboard_user import cols, diode_orientation, keymap, rows
import kmk_keyboard_user
cols = getattr(kmk_keyboard_user, 'cols')
diode_orientation = getattr(kmk_keyboard_user, 'diode_orientation')
keymap = getattr(kmk_keyboard_user, 'keymap')
rows = getattr(kmk_keyboard_user, 'rows')
try:
from kmk_keyboard_user import unicode_mode
except Exception:
unicode_mode = UnicodeModes.NOOP
DEBUG_ENABLE = getattr(kmk_keyboard_user, 'DEBUG_ENABLE', False)
if DEBUG_ENABLE:
from logging import DEBUG
else:
from logging import ERROR as DEBUG
# This will run out of ram at this point unless you manually GC
gc.collect()
try:
firmware = Firmware(
@@ -21,11 +31,13 @@ def main():
row_pins=rows,
col_pins=cols,
diode_orientation=diode_orientation,
unicode_mode=unicode_mode,
hid=HIDHelper,
leader_helper=LeaderHelper,
log_level=DEBUG,
matrix_scanner=MatrixScanner,
)
# This will run out of ram at this point unless you manually GC
gc.collect()
firmware.go()
except Exception as e:

10
kmk/firmware.py
View File

@@ -7,9 +7,10 @@ from kmk.common.internal_state import Store, kmk_reducer
class Firmware:
def __init__(
self, keymap, row_pins, col_pins,
diode_orientation, unicode_mode=None,
hid=None, log_level=logging.NOTSET,
matrix_scanner=None,
diode_orientation, unicode_mode=None,
hid=None, leader_helper=None,
log_level=logging.NOTSET,
matrix_scanner=None,
):
assert matrix_scanner is not None
self.matrix_scanner = matrix_scanner
@@ -32,12 +33,13 @@ class Firmware:
"Board will run in debug mode",
)
self.leader_helper = leader_helper(store=self.store, log_level=log_level)
self.store.dispatch(init_firmware(
keymap=keymap,
row_pins=row_pins,
col_pins=col_pins,
diode_orientation=diode_orientation,
unicode_mode=unicode_mode,
))
def _subscription(self, state, action):

2
kmk/micropython/pyb_hid.py
View File

@@ -34,6 +34,6 @@ class HIDHelper(AbstractHidHelper):
# It'd be real awesome if pyb.USB_HID.send/recv would support
# uselect.poll or uselect.select to more safely determine when
# it is safe to write to the host again...
delay(5)
delay(1)
return self