260 lines
8.3 KiB
Python
260 lines
8.3 KiB
Python
from micropython import const
|
|
from supervisor import ticks_ms
|
|
|
|
from collections import namedtuple
|
|
|
|
from kmk.keys import KC, make_argumented_key
|
|
from kmk.kmktime import check_deadline, ticks_diff
|
|
from kmk.modules import Module
|
|
|
|
|
|
class DSMeta:
|
|
def __init__(self, sequence_select=None):
|
|
self.sequence_select = sequence_select
|
|
|
|
|
|
class SequenceStatus:
|
|
STOPPED = const(0)
|
|
RECORDING = const(1)
|
|
PLAYING = const(2)
|
|
SET_REPEPITIONS = const(3)
|
|
SET_INTERVAL = const(4)
|
|
|
|
|
|
# Keycodes for number keys
|
|
_numbers = range(KC.N1.code, KC.N0.code + 1)
|
|
|
|
SequenceFrame = namedtuple('SequenceFrame', ['keys_pressed', 'timestamp'])
|
|
|
|
|
|
class Sequence:
|
|
def __init__(self):
|
|
self.repetitions = 1
|
|
self.interval = 0
|
|
self.sequence_data = [SequenceFrame(set(), 0) for i in range(3)]
|
|
|
|
|
|
class DynamicSequences(Module):
|
|
def __init__(
|
|
self, slots=1, timeout=60000, key_interval=0, use_recorded_speed=False
|
|
):
|
|
self.sequences = [Sequence() for i in range(slots)]
|
|
self.current_slot = self.sequences[0]
|
|
self.status = SequenceStatus.STOPPED
|
|
|
|
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
|
|
)
|
|
|
|
make_argumented_key(
|
|
validator=DSMeta, names=('PLAY_SEQUENCE',), on_press=self._play_sequence
|
|
)
|
|
|
|
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,
|
|
)
|
|
|
|
def _record_sequence(self, key, keyboard, *args, **kwargs):
|
|
self._stop_sequence(key, keyboard)
|
|
self.status = SequenceStatus.RECORDING
|
|
self.start_time = ticks_ms()
|
|
self.current_slot.sequence_data = [SequenceFrame(set(), 0)]
|
|
self.index = 0
|
|
|
|
def _play_sequence(self, key, keyboard, *args, **kwargs):
|
|
self._stop_sequence(key, keyboard)
|
|
self.status = SequenceStatus.PLAYING
|
|
self.start_time = ticks_ms()
|
|
self.index = 0
|
|
self.current_repetition = 0
|
|
|
|
def _stop_sequence(self, key, keyboard, *args, **kwargs):
|
|
if self.status == SequenceStatus.RECORDING:
|
|
self.stop_recording()
|
|
elif self.status == SequenceStatus.SET_INTERVAL:
|
|
self.stop_config()
|
|
self.status = SequenceStatus.STOPPED
|
|
|
|
# Change sequences here because stop is always called
|
|
if key.meta.sequence_select is not None:
|
|
self.current_slot = self.sequences[key.meta.sequence_select]
|
|
|
|
# Configure repeat settings
|
|
def _set_sequence_repetitions(self, key, keyboard, *args, **kwargs):
|
|
self._stop_sequence(key, keyboard)
|
|
self.status = SequenceStatus.SET_REPEPITIONS
|
|
self.last_config_frame = set()
|
|
self.current_slot.repetitions = 0
|
|
self.start_time = ticks_ms()
|
|
|
|
def _set_sequence_interval(self, key, keyboard, *args, **kwargs):
|
|
self._stop_sequence(key, keyboard)
|
|
self.status = SequenceStatus.SET_INTERVAL
|
|
self.last_config_frame = set()
|
|
self.current_slot.interval = 0
|
|
self.start_time = ticks_ms()
|
|
|
|
# Add the current keypress state to the sequence
|
|
def record_frame(self, keys_pressed):
|
|
if self.current_slot.sequence_data[self.index].keys_pressed != keys_pressed:
|
|
self.index += 1
|
|
|
|
# Recorded speed
|
|
if self.use_recorded_speed:
|
|
self.current_slot.sequence_data.append(
|
|
SequenceFrame(
|
|
keys_pressed.copy(), ticks_diff(ticks_ms(), self.start_time)
|
|
)
|
|
)
|
|
|
|
# Constant speed
|
|
else:
|
|
self.current_slot.sequence_data.append(
|
|
SequenceFrame(keys_pressed.copy(), self.index * self.key_interval)
|
|
)
|
|
|
|
if not check_deadline(ticks_ms(), self.start_time, self.timeout):
|
|
self.stop_recording()
|
|
|
|
# Add the ending frames to the sequence
|
|
def stop_recording(self):
|
|
# Clear the remaining keys
|
|
self.current_slot.sequence_data.append(
|
|
SequenceFrame(set(), self.current_slot.sequence_data[-1].timestamp + 20)
|
|
)
|
|
|
|
# Wait for the specified interval
|
|
prev_timestamp = self.current_slot.sequence_data[-1].timestamp
|
|
self.current_slot.sequence_data.append(
|
|
SequenceFrame(
|
|
set(),
|
|
prev_timestamp + self.current_slot.interval * 1000,
|
|
)
|
|
)
|
|
|
|
self.status = SequenceStatus.STOPPED
|
|
|
|
def play_frame(self, keyboard):
|
|
# Send the keypresses at this point in the sequence
|
|
if not check_deadline(
|
|
ticks_ms(),
|
|
self.start_time,
|
|
self.current_slot.sequence_data[self.index].timestamp,
|
|
):
|
|
if self.index:
|
|
prev = self.current_slot.sequence_data[self.index - 1].keys_pressed
|
|
cur = self.current_slot.sequence_data[self.index].keys_pressed
|
|
|
|
for key in prev.difference(cur):
|
|
keyboard.remove_key(key)
|
|
for key in cur.difference(prev):
|
|
keyboard.add_key(key)
|
|
|
|
self.index += 1
|
|
if self.index >= len(self.current_slot.sequence_data): # Reached the end
|
|
self.current_repetition += 1
|
|
if self.current_repetition == self.current_slot.repetitions:
|
|
self.status = SequenceStatus.STOPPED
|
|
else:
|
|
self.index = 0
|
|
self.start_time = ticks_ms()
|
|
|
|
# Configuration for repeating sequences
|
|
def config_mode(self, keyboard):
|
|
for key in keyboard.keys_pressed.difference(self.last_config_frame):
|
|
if key.code in _numbers:
|
|
digit = (key.code - KC.N1.code + 1) % 10
|
|
if self.status == SequenceStatus.SET_REPEPITIONS:
|
|
self.current_slot.repetitions = (
|
|
self.current_slot.repetitions * 10 + digit
|
|
)
|
|
elif self.status == SequenceStatus.SET_INTERVAL:
|
|
self.current_slot.interval = self.current_slot.interval * 10 + digit
|
|
|
|
elif key.code == KC.ENTER.code:
|
|
self.stop_config()
|
|
|
|
self.last_config_frame = keyboard.keys_pressed.copy()
|
|
keyboard.hid_pending = False # Disable typing
|
|
|
|
if not check_deadline(ticks_ms(), self.start_time, self.timeout):
|
|
self.stop_config()
|
|
|
|
# Finish configuring repetitions
|
|
def stop_config(self):
|
|
self.current_slot.sequence_data[-1] = SequenceFrame(
|
|
self.current_slot.sequence_data[-1].keys_pressed,
|
|
self.current_slot.sequence_data[-2].timestamp
|
|
+ self.current_slot.interval * 1000,
|
|
)
|
|
self.current_slot.repetitions = max(self.current_slot.repetitions, 1)
|
|
self.status = SequenceStatus.STOPPED
|
|
|
|
def on_runtime_enable(self, keyboard):
|
|
return
|
|
|
|
def on_runtime_disable(self, keyboard):
|
|
return
|
|
|
|
def during_bootup(self, keyboard):
|
|
return
|
|
|
|
def before_matrix_scan(self, keyboard):
|
|
return
|
|
|
|
def after_matrix_scan(self, keyboard):
|
|
return
|
|
|
|
def before_hid_send(self, keyboard):
|
|
|
|
if not self.status:
|
|
return
|
|
|
|
elif self.status == SequenceStatus.RECORDING:
|
|
self.record_frame(keyboard.keys_pressed)
|
|
|
|
elif self.status == SequenceStatus.PLAYING:
|
|
self.play_frame(keyboard)
|
|
|
|
elif (
|
|
self.status == SequenceStatus.SET_REPEPITIONS
|
|
or self.status == SequenceStatus.SET_INTERVAL
|
|
):
|
|
self.config_mode(keyboard)
|
|
|
|
def after_hid_send(self, keyboard):
|
|
return
|
|
|
|
def on_powersave_enable(self, keyboard):
|
|
return
|
|
|
|
def on_powersave_disable(self, keyboard):
|
|
return
|