kmk interval key

intervalkey.py

# interval_f5.py
import time
from kmk.extensions import Extension
from kmk.keys import KC, make_key
from kmk.utils import Debug

debug = Debug(__name__)

# Create an INTERNAL keycode (never sent to host)
def _interval_toggle_handler(key, keyboard, kc, coord_int):
    keyboard._interval_f5_toggle()

KC_INTERVAL_TOGGLE = make_key(
    names=('INTERVAL_F5_TOGGLE',),
    on_press=_interval_toggle_handler,
)

class IntervalF5(Extension):
    def __init__(
        self,
        interval_s=120.0,
        enabled_on_boot=False,
        trigger_immediately_on_enable=False,
        debounce_s=0.25,
        key=KC.F5,
    ):
        self.interval_s = float(interval_s)
        self.enabled = bool(enabled_on_boot)
        self.trigger_immediately_on_enable = trigger_immediately_on_enable
        self.key = key

        self._next_t = time.monotonic() + (
            0.0 if (self.enabled and trigger_immediately_on_enable)
            else self.interval_s
        )
        self._last_toggle_t = 0.0
        self._debounce_s = debounce_s

    def on_runtime_enable(self, keyboard):
        return

    def on_runtime_disable(self, keyboard):
        return

    def during_bootup(self, keyboard):
        # attach handler to keyboard instance
        keyboard._interval_f5_toggle = self._toggle
        # store reference to keyboard for sending keys
        self.keyboard = keyboard

    def before_matrix_scan(self, keyboard):
        return

    def after_matrix_scan(self, keyboard):
        return

    def before_hid_send(self, keyboard):
        return

    def on_powersave_enable(self, keyboard):
        return

    def on_powersave_disable(self, keyboard):
        return

    def _toggle(self):
        now = time.monotonic()
        if (now - self._last_toggle_t) < self._debounce_s:
            return

        self._last_toggle_t = now
        self.enabled = not self.enabled

        if self.enabled:
            self._next_t = now if self.trigger_immediately_on_enable else now + self.interval_s
            debug(f"Interval key timer started - will send {self.key} every {self.interval_s}s")
        else:
            debug(f"Interval key timer stopped - was sending {self.key} every {self.interval_s}s")

    def after_hid_send(self, keyboard):
        if not self.enabled:
            return

        now = time.monotonic()
        if now >= self._next_t:
            self.keyboard.tap_key(self.key)
            debug(f"Interval key sent: {self.key}")
            self._next_t = now + self.interval_s

kb.py

# put this in 
class POGKeyboard(KMKKeyboard):
    def __init__(self, features=['basic']):
        super().__init__()
        
   # this enables the interval key
   from intervalkey import IntervalF5
            self.extensions.append(IntervalF5(
                interval_s=30.0,           # 2 minutes
                enabled_on_boot=False,      # start disabled
                trigger_immediately_on_enable=False,
                key=KC.A,
                )
            )