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

HID fixup

Browse Source
This commit is contained in:
Kyle Brown
2020-11-11 11:19:57 -08:00
parent ab49e5edff
commit ac89e51ff1
3 changed files with 119 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

85
kmk/extensions/layers.py
View File

@@ -91,23 +91,21 @@ class Layers(Extension):
return return
@staticmethod @staticmethod
def _df_pressed(key, state, *args, **kwargs): def _df_pressed(key, keyboard, *args, **kwargs):
''' '''
Switches the default layer Switches the default layer
''' '''
state.active_layers[-1] = key.meta.layer keyboard.active_layers[-1] = key.meta.layer
return state
@staticmethod @staticmethod
def _mo_pressed(key, state, *args, **kwargs): def _mo_pressed(key, keyboard, *args, **kwargs):
''' '''
Momentarily activates layer, switches off when you let go Momentarily activates layer, switches off when you let go
''' '''
state.active_layers.insert(0, key.meta.layer) keyboard.active_layers.insert(0, key.meta.layer)
return state
@staticmethod @staticmethod
def _mo_released(key, state, KC, *args, **kwargs): def _mo_released(key, keyboard, KC, *args, **kwargs):
# remove the first instance of the target layer # remove the first instance of the target layer
# from the active list # from the active list
# under almost all normal use cases, this will # under almost all normal use cases, this will
@@ -117,95 +115,88 @@ class Layers(Extension):
# triggered by MO() and then defaulting to the MO()'s layer # triggered by MO() and then defaulting to the MO()'s layer
# would result in no layers active # would result in no layers active
try: try:
del_idx = state.active_layers.index(key.meta.layer) del_idx = keyboard.active_layers.index(key.meta.layer)
del state.active_layers[del_idx] del keyboard.active_layers[del_idx]
except ValueError: except ValueError:
pass pass
return state def _lm_pressed(self, key, keyboard, *args, **kwargs):
def _lm_pressed(self, key, state, *args, **kwargs):
''' '''
As MO(layer) but with mod active As MO(layer) but with mod active
''' '''
state.hid_pending = True keyboard.hid_pending = True
# Sets the timer start and acts like MO otherwise # Sets the timer start and acts like MO otherwise
state.keys_pressed.add(key.meta.kc) keyboard.keys_pressed.add(key.meta.kc)
return self._mo_pressed(key, state, *args, **kwargs) self._mo_pressed(key, keyboard, *args, **kwargs)
def _lm_released(self, key, state, *args, **kwargs): def _lm_released(self, key, keyboard, *args, **kwargs):
''' '''
As MO(layer) but with mod active As MO(layer) but with mod active
''' '''
state.hid_pending = True keyboard.hid_pending = True
state.keys_pressed.discard(key.meta.kc) keyboard.keys_pressed.discard(key.meta.kc)
return self._mo_released(key, state, *args, **kwargs) self._mo_released(key, keyboard, *args, **kwargs)
def _lt_pressed(self, key, state, *args, **kwargs): def _lt_pressed(self, key, keyboard, *args, **kwargs):
# Sets the timer start and acts like MO otherwise # Sets the timer start and acts like MO otherwise
self.start_time[LayerType.LT] = accurate_ticks() self.start_time[LayerType.LT] = accurate_ticks()
return self._mo_pressed(key, state, *args, **kwargs) self._mo_pressed(key, keyboard, *args, **kwargs)
def _lt_released(self, key, state, *args, **kwargs): def _lt_released(self, key, keyboard, *args, **kwargs):
# On keyup, check timer, and press key if needed. # On keyup, check timer, and press key if needed.
if self.start_time[LayerType.LT] and ( if self.start_time[LayerType.LT] and (
accurate_ticks_diff( accurate_ticks_diff(
accurate_ticks(), self.start_time[LayerType.LT], state.tap_time accurate_ticks(), self.start_time[LayerType.LT], keyboard.tap_time
) )
): ):
state.hid_pending = True keyboard.hid_pending = True
state.tap_key(key.meta.kc) keyboard.tap_key(key.meta.kc)
self._mo_released(key, state, *args, **kwargs) self._mo_released(key, keyboard, *args, **kwargs)
self.start_time[LayerType.LT] = None self.start_time[LayerType.LT] = None
return state
@staticmethod @staticmethod
def _tg_pressed(key, state, *args, **kwargs): def _tg_pressed(key, keyboard, *args, **kwargs):
''' '''
Toggles the layer (enables it if not active, and vise versa) Toggles the layer (enables it if not active, and vise versa)
''' '''
# See mo_released for implementation details around this # See mo_released for implementation details around this
try: try:
del_idx = state.active_layers.index(key.meta.layer) del_idx = keyboard.active_layers.index(key.meta.layer)
del state.active_layers[del_idx] del keyboard.active_layers[del_idx]
except ValueError: except ValueError:
state.active_layers.insert(0, key.meta.layer) keyboard.active_layers.insert(0, key.meta.layer)
return state
@staticmethod @staticmethod
def _to_pressed(key, state, *args, **kwargs): def _to_pressed(key, keyboard, *args, **kwargs):
''' '''
Activates layer and deactivates all other layers Activates layer and deactivates all other layers
''' '''
state.active_layers.clear() keyboard.active_layers.clear()
state.active_layers.insert(0, key.meta.layer) keyboard.active_layers.insert(0, key.meta.layer)
return state def _tt_pressed(self, key, keyboard, *args, **kwargs):
def _tt_pressed(self, key, state, *args, **kwargs):
''' '''
Momentarily activates layer if held, toggles it if tapped repeatedly Momentarily activates layer if held, toggles it if tapped repeatedly
''' '''
if self.start_time[LayerType.TT] is None: if self.start_time[LayerType.TT] is None:
# Sets the timer start and acts like MO otherwise # Sets the timer start and acts like MO otherwise
self.start_time[LayerType.TT] = accurate_ticks() self.start_time[LayerType.TT] = accurate_ticks()
return self._mo_pressed(key, state, *args, **kwargs) self._mo_pressed(key, keyboard, *args, **kwargs)
return
elif accurate_ticks_diff( elif accurate_ticks_diff(
accurate_ticks(), self.start_time[LayerType.TT], state.tap_time accurate_ticks(), self.start_time[LayerType.TT], keyboard.tap_time
): ):
self.start_time[LayerType.TT] = None self.start_time[LayerType.TT] = None
return self._tg_pressed(key, state, *args, **kwargs) self._tg_pressed(key, keyboard, *args, **kwargs)
return
return None return None
def _tt_released(self, key, state, *args, **kwargs): def _tt_released(self, key, keyboard, *args, **kwargs):
if self.start_time[LayerType.TT] is None or not accurate_ticks_diff( if self.start_time[LayerType.TT] is None or not accurate_ticks_diff(
accurate_ticks(), self.start_time[LayerType.TT], state.tap_time accurate_ticks(), self.start_time[LayerType.TT], keyboard.tap_time
): ):
# On first press, works like MO. On second press, does nothing unless let up within # On first press, works like MO. On second press, does nothing unless let up within
# time window, then acts like TG. # time window, then acts like TG.
self.start_time[LayerType.TT] = None self.start_time[LayerType.TT] = None
return self._mo_released(key, state, *args, **kwargs) self._mo_released(key, keyboard, *args, **kwargs)
return state

162
kmk/hid.py
View File

@@ -3,11 +3,20 @@ from micropython import const
from kmk.keys import FIRST_KMK_INTERNAL_KEY, ConsumerKey, ModifierKey from kmk.keys import FIRST_KMK_INTERNAL_KEY, ConsumerKey, ModifierKey
try:
from adafruit_ble import BLERadio
from adafruit_ble.advertising.standard import ProvideServicesAdvertisement
from adafruit_ble.services.standard.hid import HIDService
from storage import getmount
except ImportError:
# BLE not supported on this platform
pass
class HIDModes: class HIDModes:
NOOP = 0 # currently unused; for testing? NOOP = 0 # currently unused; for testing?
USB = 1 USB = 1
BLE = 2 # currently unused; for bluetooth BLE = 2
ALL_MODES = (NOOP, USB, BLE) ALL_MODES = (NOOP, USB, BLE)
@@ -225,106 +234,97 @@ class USBHID(AbstractHID):
class BLEHID(AbstractHID): class BLEHID(AbstractHID):
try: BLE_APPEARANCE_HID_KEYBOARD = const(961)
from adafruit_ble import BLERadio # Hardcoded in CPy
from adafruit_ble.advertising.standard import ProvideServicesAdvertisement MAX_CONNECTIONS = const(2)
from adafruit_ble.services.standard.hid import HIDService
from storage import getmount
BLE_APPEARANCE_HID_KEYBOARD = const(961) def post_init(self, ble_name=str(getmount('/').label), **kwargs):
# Hardcoded in CPy self.conn_id = -1
MAX_CONNECTIONS = const(2)
def post_init(self, ble_name=str(getmount('/').label), **kwargs): self.ble = BLERadio()
self.conn_id = -1 self.ble.name = ble_name
self.hid = HIDService()
self.hid.protocol_mode = 0 # Boot protocol
self.ble = self.BLERadio() # Security-wise this is not right. While you're away someone turns
self.ble.name = ble_name # on your keyboard and they can pair with it nice and clean and then
self.hid = self.HIDService() # listen to keystrokes.
self.hid.protocol_mode = 0 # Boot protocol # On the other hand we don't have LESC so it's like shouting your
# keystrokes in the air
if not self.ble.connected or not self.hid.devices:
self.start_advertising()
# Security-wise this is not right. While you're away someone turns self.conn_id = 0
# on your keyboard and they can pair with it nice and clean and then
# listen to keystrokes.
# On the other hand we don't have LESC so it's like shouting your
# keystrokes in the air
if not self.ble.connected or not self.hid.devices:
self.start_advertising()
self.conn_id = 0 @property
def devices(self):
'''Search through the provided list of devices to find the ones with the
send_report attribute.'''
if not self.ble.connected:
return []
@property result = []
def devices(self): # Security issue:
'''Search through the provided list of devices to find the ones with the # This introduces a race condition. Let's say you have 2 active
send_report attribute.''' # connections: Alice and Bob - Alice is connection 1 and Bob 2.
if not self.ble.connected: # Now Chuck who has already paired with the device in the past
return [] # (this assumption is needed only in the case of LESC)
# wants to gather the keystrokes you send to Alice. You have
# selected right now to talk to Alice (1) and you're typing a secret.
# If Chuck kicks Alice off and is quick enough to connect to you,
# which means quicker than the running interval of this function,
# he'll be earlier in the `self.hid.devices` so will take over the
# selected 1 position in the resulted array.
# If no LESC is in place, Chuck can sniff the keystrokes anyway
for device in self.hid.devices:
if hasattr(device, 'send_report'):
result.append(device)
result = [] return result
# Security issue:
# This introduces a race condition. Let's say you have 2 active
# connections: Alice and Bob - Alice is connection 1 and Bob 2.
# Now Chuck who has already paired with the device in the past
# (this assumption is needed only in the case of LESC)
# wants to gather the keystrokes you send to Alice. You have
# selected right now to talk to Alice (1) and you're typing a secret.
# If Chuck kicks Alice off and is quick enough to connect to you,
# which means quicker than the running interval of this function,
# he'll be earlier in the `self.hid.devices` so will take over the
# selected 1 position in the resulted array.
# If no LESC is in place, Chuck can sniff the keystrokes anyway
for device in self.hid.devices:
if hasattr(device, 'send_report'):
result.append(device)
return result def _check_connection(self):
devices = self.devices
if not devices:
return False
def _check_connection(self): if self.conn_id >= len(devices):
devices = self.devices self.conn_id = len(devices) - 1
if not devices:
return False
if self.conn_id >= len(devices): if self.conn_id < 0:
self.conn_id = len(devices) - 1 return False
if self.conn_id < 0: if not devices[self.conn_id]:
return False return False
if not devices[self.conn_id]: return True
return False
return True def hid_send(self, evt):
if not self._check_connection():
return
def hid_send(self, evt): device = self.devices[self.conn_id]
if not self._check_connection():
return
device = self.devices[self.conn_id] while len(evt) < len(device._characteristic.value) + 1:
evt.append(0)
while len(evt) < len(device._characteristic.value) + 1: return device.send_report(evt[1:])
evt.append(0)
return device.send_report(evt[1:]) def clear_bonds(self):
import _bleio
def clear_bonds(self): _bleio.adapter.erase_bonding()
import _bleio
_bleio.adapter.erase_bonding() def next_connection(self):
self.conn_id = (self.conn_id + 1) % len(self.devices)
def next_connection(self): def previous_connection(self):
self.conn_id = (self.conn_id + 1) % len(self.devices) self.conn_id = (self.conn_id - 1) % len(self.devices)
def previous_connection(self): def start_advertising(self):
self.conn_id = (self.conn_id - 1) % len(self.devices) advertisement = ProvideServicesAdvertisement(self.hid)
advertisement.appearance = self.BLE_APPEARANCE_HID_KEYBOARD
def start_advertising(self): self.ble.start_advertising(advertisement)
advertisement = self.ProvideServicesAdvertisement(self.hid)
advertisement.appearance = self.BLE_APPEARANCE_HID_KEYBOARD
self.ble.start_advertising(advertisement) def stop_advertising(self):
self.ble.stop_advertising()
def stop_advertising(self):
self.ble.stop_advertising()
except ImportError:
print('Bluetooth unsupported')

4
kmk/kmk_keyboard.py
View File

@@ -335,10 +335,6 @@ class KMKKeyboard:
return self return self
# Only one GC to allow for extentions to have room. There are random memory allocations
# issues due to some devices not properly cleaning memory on reset
gc.collect()
def go(self, hid_type=HIDModes.USB, **kwargs): def go(self, hid_type=HIDModes.USB, **kwargs):
self.hid_type = hid_type self.hid_type = hid_type