def psleep(self):
'''
Sleeps longer and longer to save power the more time in between updates.
'''
if ticks_diff(ticks_ms(), self._powersave_start) <= 60000:
sleep_ms(8)
elif ticks_diff(ticks_ms(), self._powersave_start) >= 240000:
sleep_ms(180)
return
def tt_pressed(key, state, *args, **kwargs):
"""Momentarily activates layer if held, toggles it if tapped repeatedly"""
# TODO Make this work with tap dance to function more correctly, but technically works.
if state.start_time['tt'] is None:
# Sets the timer start and acts like MO otherwise
state.start_time['tt'] = ticks_ms()
return mo_pressed(key, state, *args, **kwargs)
elif ticks_diff(ticks_ms(),
state.start_time['tt']) < state.config.tap_time:
state.start_time['tt'] = None
return tg_pressed(key, state, *args, **kwargs)
def set_timeout(self, after_ticks, callback):
if after_ticks is False:
# We allow passing False as an implicit "run this on the next process timeouts cycle"
timeout_key = ticks_ms()
else:
timeout_key = ticks_ms() + after_ticks
while timeout_key in self._timeouts:
timeout_key += 1
self._timeouts[timeout_key] = callback
return timeout_key
def lm_pressed(key, state, *args, **kwargs):
"""As MO(layer) but with mod active"""
state.hid_pending = True
# Sets the timer start and acts like MO otherwise
state.start_time['lm'] = ticks_ms()
state.keys_pressed.add(key.meta.kc)
return mo_pressed(key, state, *args, **kwargs)
def __init__(self, powersave_pin=None):
self.enable = False
self.powersave_pin = powersave_pin # Powersave pin board object
self._powersave_start = ticks_ms()
self._usb_last_scan = ticks_ms() - 5000
self._psp = None # Powersave pin object
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)
def tt_released(key, state, *args, **kwargs):
if (state.start_time['tt'] is None or ticks_diff(
ticks_ms(), state.start_time['tt']) >= state.config.tap_time):
# On first press, works like MO. On second press, does nothing unless let up within
# time window, then acts like TG.
state.start_time['tt'] = None
return mo_released(key, state, *args, **kwargs)
return state
def lt_released(key, state, *args, **kwargs):
# On keyup, check timer, and press key if needed.
if state.start_time['lt'] and (ticks_diff(
ticks_ms(), state.start_time['lt']) < state.config.tap_time):
state.hid_pending = True
state.tap_key(key.meta.kc)
mo_released(key, state, *args, **kwargs)
state.start_time['lt'] = None
return state
def mt_released(key, state, *args, **kwargs):
# On keyup, check timer, and press key if needed.
state.keys_pressed.discard(key.meta.mods)
timer_name = 'mod_tap'
if state.start_time[timer_name] and (ticks_diff(
ticks_ms(), state.start_time[timer_name]) < state.config.tap_time):
state.hid_pending = True
state.tap_key(key.meta.kc)
state.start_time[timer_name] = None
return state
def __init__(
self,
split_flip=True,
split_side=None,
split_type=SplitType.UART,
split_target_left=True,
uart_interval=20,
data_pin=None,
data_pin2=None,
target_left=True,
uart_flip=True,
debug_enabled=False,
):
self._is_target = True
self._uart_buffer = []
self.split_flip = split_flip
self.split_side = split_side
self.split_type = split_type
self.split_target_left = split_target_left
self.split_offset = None
self.data_pin = data_pin
self.data_pin2 = data_pin2
self.target_left = target_left
self.uart_flip = uart_flip
self._is_target = True
self._uart = None
self._uart_interval = uart_interval
self._debug_enabled = debug_enabled
if self.split_type == SplitType.BLE:
try:
from adafruit_ble import BLERadio
from adafruit_ble.advertising.standard import (
ProvideServicesAdvertisement,
)
from adafruit_ble.services.nordic import UARTService
self.ProvideServicesAdvertisement = ProvideServicesAdvertisement
self.UARTService = UARTService
except ImportError:
print('BLE Import error')
return # BLE isn't supported on this platform
self._ble = BLERadio()
self._ble_last_scan = ticks_ms() - 5000
self._connection_count = 0
self._uart_connection = None
self._advertisment = None
self._advertising = False
self._psave_enable = False
def _process_timeouts(self):
if not self._timeouts:
return self
current_time = ticks_ms()
# cast this to a tuple to ensure that if a callback itself sets
# timeouts, we do not handle them on the current cycle
timeouts = tuple(self._timeouts.items())
for k, v in timeouts:
if k <= current_time:
v()
del self._timeouts[k]
return self
def mt_pressed(key, state, *args, **kwargs):
# Sets the timer start and acts like a modifier otherwise
state.keys_pressed.add(key.meta.mods)
state.start_time['mod_tap'] = ticks_ms()
return state
def ble_time_reset(self):
'''Resets the rescan timer'''
self._ble_last_scan = ticks_ms()
def usb_time_reset(self):
self._usb_last_scan = ticks_ms()
return
def usb_rescan_timer(self):
return bool(ticks_diff(ticks_ms(), self._usb_last_scan) > 5000)
def psave_time_reset(self):
self._powersave_start = ticks_ms()
def lt_pressed(key, state, *args, **kwargs):
# Sets the timer start and acts like MO otherwise
state.start_time['lt'] = ticks_ms()
return mo_pressed(key, state, *args, **kwargs)
def report(self):
new_encoder_state = (
self.encoder_pad_lookup[int(self.pad_a.value)],
self.encoder_pad_lookup[int(self.pad_b.value)],
)
if self.encoder_state == (self.eps.ON,
self.eps.ON): # Resting position
if new_encoder_state == (self.eps.ON,
self.eps.OFF): # Turned right 1
self.encoder_direction = self.edr.Right
elif new_encoder_state == (self.eps.OFF,
self.eps.ON): # Turned left 1
self.encoder_direction = self.edr.Left
elif self.encoder_state == (self.eps.ON,
self.eps.OFF): # R1 or L3 position
if new_encoder_state == (self.eps.OFF,
self.eps.OFF): # Turned right 1
self.encoder_direction = self.edr.Right
elif new_encoder_state == (self.eps.ON,
self.eps.ON): # Turned left 1
if self.encoder_direction == self.edr.Left:
self.encoder_value = self.encoder_value - 1
elif self.encoder_state == (self.eps.OFF, self.eps.ON): # R3 or L1
if new_encoder_state == (self.eps.OFF,
self.eps.OFF): # Turned left 1
self.encoder_direction = self.edr.Left
elif new_encoder_state == (self.eps.ON,
self.eps.ON): # Turned right 1
if self.encoder_direction == self.edr.Right:
self.encoder_value = self.encoder_value + 1
else: # self.encoder_state == '11'
if new_encoder_state == (self.eps.ON,
self.eps.OFF): # Turned left 1
self.encoder_direction = self.edr.Left
elif new_encoder_state == (self.eps.OFF,
self.eps.ON): # Turned right 1
self.encoder_direction = self.edr.Right # 'R'
elif new_encoder_state == (
self.eps.ON,
self.eps.ON,
): # Skipped intermediate 01 or 10 state, however turn completed
if self.encoder_direction == self.edr.Left:
self.encoder_value = self.encoder_value - 1
elif self.encoder_direction == self.edr.Right:
self.encoder_value = self.encoder_value + 1
self.encoder_state = new_encoder_state
if self.vel_mode:
self.vel_ts = ticks_ms()
if self.encoder_state != self.last_encoder_state:
self.position_change = self.invert_rotation(
self.encoder_value, self.last_encoder_value)
self.last_encoder_state = self.encoder_state
self.last_encoder_value = self.encoder_value
if self.position_change > 0:
self._to_dict()
# return self.increment_key
return 0
elif self.position_change < 0:
self._to_dict()
# return self.decrement_key
return 1
else:
return None
def ble_rescan_timer(self):
'''If true, the rescan timer is up'''
return bool(ticks_diff(ticks_ms(), self._ble_last_scan) > 5000)
