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

Reduce key dictionary memory footprint

Browse Source 
Instead of indexing `Key` objects that have multiple names by each
individual name, index by the set of names. This reduces the size of the
default key dictionary by a factor of between 2 and 3, and as result
also reduces reallocations/defragmentation.
Instead of instantiating all module/extension keys by default, append
them to the `maybe_key`-generator list.
This commit is contained in:
xs5871
2022-12-05 19:54:57 +00:00
parent 47c242a2c9
commit 9c1bd210eb
27 changed files with 439 additions and 434 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
kmk/modules/capsword.py
View File

@@ -1,4 +1,5 @@
from kmk.keys import FIRST_KMK_INTERNAL_KEY, KC, ModifierKey, make_key
from kmk.handlers.stock import passthrough as handler_passthrough
from kmk.keys import FIRST_KMK_INTERNAL_KEY, KC, ModifierKey, maybe_make_key
from kmk.modules import Module
@@ -16,12 +17,16 @@ class CapsWord(Module):
self._timeout_key = False
self._cw_active = False
self.timeout = timeout
make_key(
KC._generators.append(self.maybe_make_capsword_key())
def maybe_make_capsword_key(self):
return maybe_make_key(
names=(
'CAPSWORD',
'CW',
),
on_press=self.cw_pressed,
on_release=handler_passthrough,
)
def during_bootup(self, keyboard):

27
kmk/modules/cg_swap.py
View File

@@ -1,3 +1,4 @@
from kmk.handlers.stock import passthrough as handler_passthrough
from kmk.keys import KC, ModifierKey, make_key
from kmk.modules import Module
@@ -12,16 +13,26 @@ class CgSwap(Module):
KC.LGUI: KC.LCTL,
KC.RGUI: KC.RCTL,
}
make_key(
names=('CG_SWAP',),
)
make_key(
names=('CG_NORM',),
)
make_key(
names=('CG_TOGG',),
KC._generators.append(self.maybe_make_cgswap_key())
def maybe_make_cgswap_key(self):
keys = (
(('CG_SWAP',),),
(('CG_NORM',),),
(('CG_TOGG',),),
)
def closure(candidate):
for names in keys:
if candidate in names:
return make_key(
names=names,
on_press=handler_passthrough,
on_release=handler_passthrough,
)
return closure
def during_bootup(self, keyboard):
return

13
kmk/modules/combos.py
View File

@@ -5,7 +5,7 @@ except ImportError:
from micropython import const
import kmk.handlers.stock as handlers
from kmk.keys import Key, make_key
from kmk.keys import KC, Key, maybe_make_key
from kmk.kmk_keyboard import KMKKeyboard
from kmk.modules import Module
@@ -102,11 +102,12 @@ class Combos(Module):
def __init__(self, combos=[]):
self.combos = combos
self._key_buffer = []
make_key(
names=('LEADER', 'LDR'),
on_press=handlers.passthrough,
on_release=handlers.passthrough,
KC._generators.append(
maybe_make_key(
names=('LEADER', 'LDR'),
on_press=handlers.passthrough,
on_release=handlers.passthrough,
)
)
def during_bootup(self, keyboard):

47
kmk/modules/dynamic_sequences.py
View File

@@ -3,6 +3,7 @@ from supervisor import ticks_ms
from collections import namedtuple
from kmk.handlers.stock import passthrough as handler_passthrough
from kmk.keys import KC, make_argumented_key
from kmk.kmktime import check_deadline, ticks_diff
from kmk.modules import Module
@@ -45,41 +46,33 @@ class DynamicSequences(Module):
self.index = 0
self.start_time = 0
self.current_repetition = 0
self.last_config_frame = set()
self.timeout = timeout
self.key_interval = key_interval
self.use_recorded_speed = use_recorded_speed
# Create keycodes
make_argumented_key(
validator=DSMeta, names=('RECORD_SEQUENCE',), on_press=self._record_sequence
KC._generators.append(self.maybe_make_sequence_key())
def maybe_make_sequence_key(self):
keys = (
(('RECORD_SEQUENCE',), DSMeta, self._record_sequence),
(('PLAY_SEQUENCE',), DSMeta, self._play_sequence),
(('SET_SEQUENCE', 'STOP_SEQUENCE'), DSMeta, self._stop_sequence),
(('SET_SEQUENCE_REPETITIONS',), DSMeta, self._set_sequence_repetitions),
(('SET_SEQUENCE_INTERVAL',), DSMeta, self._set_sequence_interval),
)
make_argumented_key(
validator=DSMeta, names=('PLAY_SEQUENCE',), on_press=self._play_sequence
)
def closure(candidate):
for names, validator, on_press in keys:
if candidate in names:
return make_argumented_key(
names=names,
validator=validator,
on_press=on_press,
on_release=handler_passthrough,
)
make_argumented_key(
validator=DSMeta,
names=(
'SET_SEQUENCE',
'STOP_SEQUENCE',
),
on_press=self._stop_sequence,
)
make_argumented_key(
validator=DSMeta,
names=('SET_SEQUENCE_REPETITIONS',),
on_press=self._set_sequence_repetitions,
)
make_argumented_key(
validator=DSMeta,
names=('SET_SEQUENCE_INTERVAL',),
on_press=self._set_sequence_interval,
)
return closure
def _record_sequence(self, key, keyboard, *args, **kwargs):
self._stop_sequence(key, keyboard)

14
kmk/modules/holdtap.py
View File

@@ -1,6 +1,6 @@
from micropython import const
from kmk.keys import KC, make_argumented_key
from kmk.keys import KC, maybe_make_argumented_key
from kmk.modules import Module
from kmk.utils import Debug
@@ -55,11 +55,13 @@ class HoldTap(Module):
self.key_buffer = []
self.key_states = {}
if not KC.get('HT'):
make_argumented_key(
validator=HoldTapKeyMeta,
names=('HT',),
on_press=self.ht_pressed,
on_release=self.ht_released,
KC._generators.append(
maybe_make_argumented_key(
validator=HoldTapKeyMeta,
names=('HT',),
on_press=self.ht_pressed,
on_release=self.ht_released,
)
)
def during_bootup(self, keyboard):

62
kmk/modules/layers.py
View File

@@ -1,4 +1,5 @@
'''One layer isn't enough. Adds keys to get to more of them'''
from kmk.handlers.stock import passthrough as handler_passthrough
from kmk.keys import KC, make_argumented_key
from kmk.modules.holdtap import HoldTap, HoldTapKeyMeta
from kmk.utils import Debug
@@ -39,46 +40,31 @@ class Layers(HoldTap):
def __init__(self):
# Layers
super().__init__()
make_argumented_key(
validator=layer_key_validator,
names=('MO',),
on_press=self._mo_pressed,
on_release=self._mo_released,
)
make_argumented_key(
validator=layer_key_validator,
names=('DF',),
on_press=self._df_pressed,
)
make_argumented_key(
validator=layer_key_validator,
names=('LM',),
on_press=self._lm_pressed,
on_release=self._lm_released,
)
make_argumented_key(
validator=layer_key_validator,
names=('TG',),
on_press=self._tg_pressed,
)
make_argumented_key(
validator=layer_key_validator,
names=('TO',),
on_press=self._to_pressed,
)
make_argumented_key(
validator=layer_key_validator_lt,
names=('LT',),
on_press=self.ht_pressed,
on_release=self.ht_released,
)
make_argumented_key(
validator=layer_key_validator_tt,
names=('TT',),
on_press=self.ht_pressed,
on_release=self.ht_released,
KC._generators.append(self.maybe_make_layer_key())
def maybe_make_layer_key(self):
keys = (
(('MO',), layer_key_validator, self._mo_pressed, self._mo_released),
(('DF',), layer_key_validator, self._df_pressed, handler_passthrough),
(('LM',), layer_key_validator, self._lm_pressed, self._lm_released),
(('TG',), layer_key_validator, self._tg_pressed, handler_passthrough),
(('TO',), layer_key_validator, self._to_pressed, handler_passthrough),
(('LT',), layer_key_validator_lt, self.ht_pressed, self.ht_released),
(('TT',), layer_key_validator_tt, self.ht_pressed, self.ht_released),
)
def closure(candidate):
for names, validator, on_press, on_release in keys:
if candidate in names:
return make_argumented_key(
names=names,
validator=validator,
on_press=on_press,
on_release=on_release,
)
return closure
def _df_pressed(self, key, keyboard, *args, **kwargs):
'''
Switches the default layer

70
kmk/modules/midi.py
View File

@@ -8,7 +8,8 @@ from adafruit_midi.program_change import ProgramChange
from adafruit_midi.start import Start
from adafruit_midi.stop import Stop
from kmk.keys import make_argumented_key
from kmk.handlers.stock import passthrough as handler_passthrough
from kmk.keys import KC, make_argumented_key
from kmk.modules import Module
@@ -21,42 +22,6 @@ class midiNoteValidator:
class MidiKeys(Module):
def __init__(self):
make_argumented_key(
names=('MIDI_CC',),
validator=ControlChange,
on_press=self.on_press,
)
make_argumented_key(
names=('MIDI_NOTE',),
validator=midiNoteValidator,
on_press=self.note_on,
on_release=self.note_off,
)
make_argumented_key(
names=('MIDI_PB',),
validator=PitchBend,
on_press=self.on_press,
)
make_argumented_key(
names=('MIDI_PC',),
validator=ProgramChange,
on_press=self.on_press,
)
make_argumented_key(
names=('MIDI_START',),
validator=Start,
on_press=self.on_press,
)
make_argumented_key(
names=('MIDI_STOP',),
validator=Stop,
on_press=self.on_press,
)
try:
self.midi = adafruit_midi.MIDI(midi_out=usb_midi.ports[1], out_channel=0)
@@ -65,6 +30,37 @@ class MidiKeys(Module):
# if debug_enabled:
print('No midi device found.')
KC._generators.append(self.maybe_make_midi_key())
def maybe_make_midi_key(self):
keys = (
(('MIDI_CC',), ControlChange),
(('MIDI_PB',), PitchBend),
(('MIDI_PC',), ProgramChange),
(('MIDI_START',), Start),
(('MIDI_STOP',), Stop),
)
note = ('MIDI_NOTE',)
def closure(candidate):
if candidate in note:
return make_argumented_key(
names=('MIDI_NOTE',),
validator=midiNoteValidator,
on_press=self.note_on,
on_release=self.note_off,
)
for names, validator in keys:
if candidate in names:
return make_argumented_key(
names=names,
validator=validator,
on_press=self.on_press,
on_release=handler_passthrough,
)
return closure
def during_bootup(self, keyboard):
return None

14
kmk/modules/modtap.py
View File

@@ -1,13 +1,15 @@
from kmk.keys import make_argumented_key
from kmk.keys import KC, maybe_make_argumented_key
from kmk.modules.holdtap import HoldTap, HoldTapKeyMeta
class ModTap(HoldTap):
def __init__(self):
super().__init__()
make_argumented_key(
validator=HoldTapKeyMeta,
names=('MT',),
on_press=self.ht_pressed,
on_release=self.ht_released,
KC._generators.append(
maybe_make_argumented_key(
validator=HoldTapKeyMeta,
names=('MT',),
on_press=self.ht_pressed,
on_release=self.ht_released,
)
)

79
kmk/modules/mouse_keys.py
View File

@@ -1,7 +1,7 @@
from supervisor import ticks_ms
from kmk.hid import HID_REPORT_SIZES, HIDReportTypes
from kmk.keys import make_key
from kmk.keys import KC, make_key
from kmk.modules import Module
@@ -34,65 +34,30 @@ class MouseKeys(Module):
self.ac_interval = 100 # Delta ms to apply acceleration
self._next_interval = 0 # Time for next tick interval
self.move_step = 1
KC._generators.append(self.maybe_make_mouse_key())
make_key(
names=('MB_LMB',),
on_press=self._mb_lmb_press,
on_release=self._mb_lmb_release,
)
make_key(
names=('MB_MMB',),
on_press=self._mb_mmb_press,
on_release=self._mb_mmb_release,
)
make_key(
names=('MB_RMB',),
on_press=self._mb_rmb_press,
on_release=self._mb_rmb_release,
)
make_key(
names=('MW_UP',),
on_press=self._mw_up_press,
on_release=self._mw_up_release,
)
make_key(
names=(
'MW_DOWN',
'MW_DN',
),
on_press=self._mw_down_press,
on_release=self._mw_down_release,
)
make_key(
names=('MS_UP',),
on_press=self._ms_up_press,
on_release=self._ms_up_release,
)
make_key(
names=(
'MS_DOWN',
'MS_DN',
),
on_press=self._ms_down_press,
on_release=self._ms_down_release,
)
make_key(
names=(
'MS_LEFT',
'MS_LT',
),
on_press=self._ms_left_press,
on_release=self._ms_left_release,
)
make_key(
names=(
'MS_RIGHT',
'MS_RT',
),
on_press=self._ms_right_press,
on_release=self._ms_right_release,
def maybe_make_mouse_key(self):
keys = (
(('MB_LMB',), self._mb_lmb_press, self._mb_lmb_release),
(('MB_MMB',), self._mb_mmb_press, self._mb_mmb_release),
(('MB_RMB',), self._mb_rmb_press, self._mb_rmb_release),
(('MW_UP',), self._mw_up_press, self._mw_up_release),
(('MW_DOWN', 'MW_DN'), self._mw_down_press, self._mw_down_release),
(('MS_UP',), self._ms_up_press, self._ms_up_release),
(('MS_DOWN', 'MS_DN'), self._ms_down_press, self._ms_down_release),
(('MS_LEFT', 'MS_LT'), self._ms_left_press, self._ms_left_release),
(('MS_RIGHT', 'MS_RT'), self._ms_right_press, self._ms_right_release),
)
def closure(candidate):
for names, on_press, on_release in keys:
if candidate in names:
return make_key(
names=names, on_press=on_press, on_release=on_release
)
return closure
def during_bootup(self, keyboard):
return

14
kmk/modules/oneshot.py
View File

@@ -1,4 +1,4 @@
from kmk.keys import make_argumented_key
from kmk.keys import KC, maybe_make_argumented_key
from kmk.modules.holdtap import ActivationType, HoldTap, HoldTapKeyMeta
@@ -11,11 +11,13 @@ class OneShot(HoldTap):
def __init__(self):
super().__init__()
make_argumented_key(
validator=oneshot_validator,
names=('OS', 'ONESHOT'),
on_press=self.osk_pressed,
on_release=self.osk_released,
KC._generators.append(
maybe_make_argumented_key(
validator=oneshot_validator,
names=('OS', 'ONESHOT'),
on_press=self.osk_pressed,
on_release=self.osk_released,
)
)
def process_key(self, keyboard, current_key, is_pressed, int_coord):

21
kmk/modules/pimoroni_trackball.py
View File

@@ -7,7 +7,7 @@ from micropython import const
import math
import struct
from kmk.keys import make_argumented_key, make_key
from kmk.keys import KC, maybe_make_argumented_key, maybe_make_key
from kmk.kmktime import PeriodicTimer
from kmk.modules import Module
from kmk.modules.mouse_keys import PointingDevice
@@ -198,15 +198,18 @@ class Trackball(Module):
f'Invalid chip ID: 0x{chip_id:04X}, expected 0x{CHIP_ID:04X}'
)
make_key(
names=('TB_MODE', 'TB_NEXT_HANDLER', 'TB_N'),
on_press=self._tb_handler_next_press,
KC._generators.append(
maybe_make_key(
names=('TB_MODE', 'TB_NEXT_HANDLER', 'TB_N'),
on_press=self._tb_handler_next_press,
)
)
make_argumented_key(
validator=layer_key_validator,
names=('TB_HANDLER', 'TB_H'),
on_press=self._tb_handler_press,
KC._generators.append(
maybe_make_argumented_key(
validator=layer_key_validator,
names=('TB_HANDLER', 'TB_H'),
on_press=self._tb_handler_press,
)
)
def during_bootup(self, keyboard):

28
kmk/modules/power.py
View File

@@ -5,7 +5,7 @@ from supervisor import ticks_ms
from time import sleep
from kmk.handlers.stock import passthrough as handler_passthrough
from kmk.keys import make_key
from kmk.keys import KC, make_key
from kmk.kmktime import check_deadline
from kmk.modules import Module
@@ -20,16 +20,26 @@ class Power(Module):
self._i2c = 0
self._loopcounter = 0
make_key(
names=('PS_TOG',), on_press=self._ps_tog, on_release=handler_passthrough
)
make_key(
names=('PS_ON',), on_press=self._ps_enable, on_release=handler_passthrough
)
make_key(
names=('PS_OFF',), on_press=self._ps_disable, on_release=handler_passthrough
KC._generators.append(self.maybe_make_power_key())
def maybe_make_power_key(self):
keys = (
(('PS_TOG',), self._ps_tog),
(('PS_ON',), self._ps_enable),
(('PS_OFF',), self._ps_disable),
)
def closure(candidate):
for names, on_press in keys:
if candidate in names:
return make_key(
names=names,
on_press=on_press,
on_release=handler_passthrough,
)
return closure
def __repr__(self):
return f'Power({self._to_dict()})'

14
kmk/modules/rapidfire.py
View File

@@ -1,6 +1,6 @@
from random import randint
from kmk.keys import make_argumented_key
from kmk.keys import KC, maybe_make_argumented_key
from kmk.modules import Module
@@ -28,11 +28,13 @@ class RapidFire(Module):
_waiting_keys = []
def __init__(self):
make_argumented_key(
validator=RapidFireMeta,
names=('RF',),
on_press=self._rf_pressed,
on_release=self._rf_released,
KC._generators.append(
maybe_make_argumented_key(
validator=RapidFireMeta,
names=('RF',),
on_press=self._rf_pressed,
on_release=self._rf_released,
)
)
def _get_repeat(self, key):

14
kmk/modules/sticky_mod.py
View File

@@ -1,4 +1,4 @@
from kmk.keys import make_argumented_key
from kmk.keys import KC, maybe_make_argumented_key
from kmk.modules import Module
@@ -12,11 +12,13 @@ class StickyMod(Module):
def __init__(self):
self._active = False
self._active_key = None
make_argumented_key(
names=('SM',),
validator=StickyModMeta,
on_press=self.sm_pressed,
on_release=self.sm_released,
KC._generators.append(
maybe_make_argumented_key(
names=('SM',),
validator=StickyModMeta,
on_press=self.sm_pressed,
on_release=self.sm_released,
)
)
def during_bootup(self, keyboard):

14
kmk/modules/tapdance.py
View File

@@ -1,4 +1,4 @@
from kmk.keys import KC, make_argumented_key
from kmk.keys import KC, maybe_make_argumented_key
from kmk.modules.holdtap import ActivationType, HoldTap, HoldTapKeyMeta
@@ -30,11 +30,13 @@ class TapDanceKeyMeta:
class TapDance(HoldTap):
def __init__(self):
super().__init__()
make_argumented_key(
validator=TapDanceKeyMeta,
names=('TD',),
on_press=self.td_pressed,
on_release=self.td_released,
KC._generators.append(
maybe_make_argumented_key(
validator=TapDanceKeyMeta,
names=('TD',),
on_press=self.td_pressed,
on_release=self.td_released,
)
)
self.td_counts = {}