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)