razer-analog 0.1.0__tar.gz

razer_analog-0.1.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: razer-analog
+Version: 0.1.0
+Summary: 
+License: GPL-2
+Author: Dick Marinus
+Requires-Python: >=3.10,<4.0
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: evdev (>=1.6.0,<2.0.0)
+Requires-Dist: ioctl-opt (>=1.2.2,<2.0.0)
+Requires-Dist: pyudev (>=0.24.0,<0.25.0)

razer_analog-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[tool.poetry]
+name = "razer-analog"
+version = "0.1.0"
+description = ""
+authors = ["Dick Marinus"]
+license = "GPL-2"
+#readme = "README.md"
+#packages = [{include = "razer_analog"}]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+ioctl-opt = "^1.2.2"
+evdev = "^1.6.0"
+pyudev = "^0.24.0"
+
+[tool.poetry.group.dev.dependencies]
+pylint = "^2.15.10"
+mypy = "^0.991"
+coverage = "^7.0.5"
+pytest = "^7.2.1"
+pytest-cov = "^4.0.0"
+black = "^23.1.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.scripts]
+razer-analog = 'razer_analog.driver:main'
+razer-analog-mouse = 'razer_analog.mouse:main'
+razerctl = 'razer_analog.razerctl:main'
+hidrawtests = 'razer_analog.hidrawtests:main'

razer_analog-0.1.0/razer_analog/driver.py

@@ -0,0 +1,399 @@
+"""
+Razer Analog driver
+"""
+import asyncio
+import os
+import struct
+import atexit
+import signal
+import sys
+import typing
+import io
+import time
+
+import evdev  # type: ignore
+import pyudev  # type: ignore
+
+import razer_analog.layout
+import razer_analog.hidraw
+
+
+class HuntsmanMiniAnalog:
+    """
+    Huntsman Mini Analog class
+    """
+
+    def __init__(
+        self, pressed_queue: asyncio.Queue[typing.Dict[int, int]], parent: str
+    ):
+        self.report_queue: asyncio.Queue[bytes] = asyncio.Queue()
+        self.pressed_queue: asyncio.Queue[typing.Dict[int, int]] = pressed_queue
+        self.devices: typing.List[io.BufferedReader] = []
+        self.context = pyudev.Context()
+        self.parent = pyudev.Devices.from_path(self.context, parent)
+
+        self.open()
+
+        self.monitor = pyudev.Monitor.from_netlink(self.context)
+        self.monitor.filter_by(subsystem="hidraw")
+        self.monitor.start()
+
+    def open(self) -> None:
+        """
+        Open device
+        """
+        self.devices = []
+        loop = asyncio.get_event_loop()
+        for udev in self.context.list_devices(parent=self.parent, subsystem="hidraw"):
+            # pylint: disable=consider-using-with
+            device_handle = open(udev.device_node, "rb")
+            os.set_blocking(device_handle.fileno(), False)
+            hidraw = razer_analog.hidraw.HIDRaw(device_handle)
+            i = hidraw.getInfo()
+            if i.vendor == 0x1532 and i.product == 0x0282:
+                self.devices.append(device_handle)
+                loop.add_reader(device_handle.fileno(), self.read, device_handle)
+                desc = hidraw.getRawReportDescriptor()
+                # I'd like to parse these using python-hid-parser but that needs to be
+                # fixed in: https://github.com/usb-tools/python-hid-parser/pull/17
+                # fmt: off
+                if list(desc) == [5, 12, 9, 1, 161, 1, 6, 0, 255, 9, 2, 21, 0, 37, 1,
+                    117, 8, 149, 90, 177, 1, 192,
+                ]:
+                    # put control interface first
+                    self.devices[0], self.devices[-1] = self.devices[-1], self.devices[0]
+                elif list(desc) == [ 5, 1, 9, 6, 161, 1, 133, 1, 5, 7, 5, 7, 25, 224, 41,
+                    231, 21, 0, 37, 1, 117, 1, 149, 8, 129, 2, 25, 0, 41, 160, 21,
+                    0, 37, 1, 117, 1, 149, 160, 129, 2, 117, 8, 149, 2, 129, 1, 5,
+                    8, 25, 1, 41, 3, 21, 0, 37, 1, 117, 1, 149, 3, 145, 2, 149, 5,
+                    145, 1, 192, 5, 12, 9, 1, 161, 1, 133, 2, 25, 0, 42, 60, 2, 21,
+                    0, 38, 60, 2, 149, 1, 117, 16, 129, 0, 117, 8, 149, 21, 129, 1,
+                    192, 5, 1, 9, 128, 161, 1, 133, 3, 25, 129, 41, 131, 21, 0, 37,
+                    1, 117, 1, 149, 3, 129, 2, 149, 5, 129, 1, 117, 8, 149, 22, 129,
+                    1, 192, 5, 1, 9, 0, 161, 1, 133, 4, 9, 3, 21, 0, 38, 255, 0, 53,
+                    0, 70, 255, 0, 117, 8, 149, 23, 129, 0, 192, 5, 1, 9, 0, 161, 1,
+                    133, 5, 9, 3, 21, 0, 38, 255, 0, 53, 0, 70, 255, 0, 117, 8, 149,
+                    23, 129, 0, 192, 5, 1, 9, 0, 161, 1, 133, 7, 9, 3, 21, 0, 38,
+                    255, 0, 53, 0, 70, 255, 0, 117, 8, 149, 23, 129, 0, 192,
+                ]:
+                    pass
+                # fmt: on
+            else:
+                device_handle.close()
+
+    def close(self) -> None:
+        """
+        close device
+        """
+        loop = asyncio.get_event_loop()
+        for device in self.devices:
+            loop.remove_reader(device.fileno())
+            device.close()
+        self.devices = []
+
+    def read(self, device_handle: io.BufferedReader) -> None:
+        """
+        read from device
+        """
+        try:
+            buf = device_handle.read(2048)
+        except OSError:
+            print("failed to read, exiting")
+            self.close()
+            sys.exit()
+        while buf:
+            if buf[0] == 0x04:
+                pass  #  For some reason presses of Fn are reported here
+            elif buf[0] == 0x07:
+                self.report_queue.put_nowait(buf[1:23])
+            else:
+                print([buf])
+            buf = buf[24:]
+
+    @staticmethod
+    def crc(buf: bytes) -> int:
+        """
+        Calculate Razer CRC
+        """
+        result = 0
+        for i in range(2, 86):
+            result ^= buf[i]
+        return result
+
+    def razer_command(self, data: bytes) -> bytes:
+        """
+        Send a razer command
+        """
+        if not self.devices:
+            print("cannot send command, no devices attached")
+            return b""
+
+        hidraw = razer_analog.hidraw.HIDRaw(self.devices[0])
+        send_report = struct.pack(
+            ">BBHBB",
+            0x00,  # status
+            0x1F,  # transaction_id
+            0x00,  # remaining_packets
+            0x00,  # protocol_type
+            len(data) - 2,  # size
+        )
+        send_report += data
+        send_report += b"\x00" * (82 - len(data))
+        send_report += bytes([self.crc(send_report)])
+        send_report += b"\x00"
+        hidraw.sendFeatureReport(send_report)
+        received_report = hidraw.getFeatureReport(0, 90)
+
+        if received_report[1] != 0x02:  # SUCCESS
+            print(
+                f"Failed razer_command ({received_report[1]}). received_report, send_report"
+            )
+            print(received_report)
+            print(send_report)
+
+        return received_report
+
+    def set_device_mode(self, mode: int) -> None:
+        """
+        Set device mode
+        """
+        data = b"\x00\x04" + bytes((mode, 0x00))
+        received_report = self.razer_command(data)[7:11]
+        if received_report != data:
+            print("set_device_mode mismatch", data, received_report)
+
+    async def run(self) -> None:
+        """
+        Main loop
+        """
+        previous_pressed_keys: typing.Set[int] = set([])
+        while True:
+            report = await self.report_queue.get()
+            pressed = {}
+            for i in range(0, len(report), 2):
+                if report[i] == 0 and report[i + 1] == 0:
+                    break
+                key, value = report[i : i + 2]
+                pressed[key] = value
+            # add key_up = 0 when pressed key "disappear" to simplify
+            # handling of events.
+            for key_up in previous_pressed_keys - set(pressed.keys()):
+                pressed[key_up] = 0
+            await self.pressed_queue.put(pressed)
+            previous_pressed_keys = set(pressed.keys())
+
+    async def client_connected(
+        self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+    ) -> None:
+        """
+        Call back when a client connects to the control socket
+        """
+        while True:
+            pktlen = await reader.read(1)
+            if pktlen == b"\x00":
+                return
+            try:
+                data = await reader.readexactly(pktlen[0])
+            except asyncio.IncompleteReadError:
+                break
+            if len(data) > 2:
+                received_report = self.razer_command(data)
+                if received_report:
+                    writer.write(bytes((len(received_report),)) + received_report)
+                    try:
+                        await writer.drain()
+                    except ConnectionResetError:
+                        print("disconnect")
+                        return
+                else:
+                    print("empty reply")
+            else:
+                print("received insufficient data")
+
+    async def unix_server(self) -> None:
+        """
+        Start control socket
+        """
+        server = await asyncio.start_unix_server(
+            self.client_connected, path=f"/var/run/razer-analog-{os.getpid()}"
+        )
+        async with server:
+            await server.serve_forever()
+
+
+async def user_input_write(
+    user_input: evdev.UInput,
+    user_input_queue: asyncio.Queue[typing.Tuple[int, int, int]],
+) -> None:
+    """
+    Write user_input_queue to UInput device
+    """
+    while True:
+        etype, code, value = await user_input_queue.get()
+        user_input.write(etype, code, value)
+        user_input.syn()
+
+
+def released_modifier_keys(
+    leftmeta_released: bool,
+    leftmeta_in_repeat: bool,
+    fn_released: bool,
+    fn_in_repeat: bool,
+) -> bool:
+    """
+    Modifier keys are released and previously pressed
+    """
+    return (
+        (leftmeta_released and leftmeta_in_repeat)
+        or (fn_released and leftmeta_in_repeat)
+        or (fn_released and leftmeta_released and fn_in_repeat)
+    )
+
+
+def key_triggered(triggered: typing.Dict[int, bool], key: int, value: int) -> bool:
+    """
+    Check if key should trigger
+    """
+    if value < 96:
+        triggered[key] = False
+        return False
+    if value > 128:
+        triggered[key] = True
+        return True
+    return triggered.get(key, False)
+
+
+def razer_key_pressed(
+    pressed_keys: typing.Dict[int, int],
+    triggered: typing.Dict[int, bool],
+    razer_key: str,
+) -> bool:
+    """
+    Check if key is pressed
+    """
+    razer_keys = {
+        "FN": 59,
+        "LEFTMETA": 127,
+    }
+    key = razer_keys[razer_key]
+    value = pressed_keys.get(key, 0)
+    return key_triggered(triggered, key, value)
+
+
+async def virtual_keyboard(
+    pressed_queue: asyncio.Queue[typing.Dict[int, int]],
+    user_input_queue: asyncio.Queue[typing.Tuple[int, int, int]],
+) -> None:
+    """
+    Handle Fn layout, left meta as Fn, FnFn as left meta and keyboard repeat
+    """
+    repeat: typing.Dict[int, float] = {}
+    triggered: typing.Dict[int, bool] = {}
+    while True:
+        try:
+            pressed_keys: typing.Dict[int, int] = pressed_queue.get_nowait()
+        except asyncio.QueueEmpty:
+            await asyncio.sleep(0.03)
+            for pressed_key, repeat_until in repeat.items():
+                if time.monotonic() > repeat_until:
+                    await user_input_queue.put(
+                        (evdev.ecodes.ecodes["EV_KEY"], pressed_key, 2)
+                    )
+            continue
+
+        layout = razer_analog.layout.get_layout(
+            razer_key_pressed(pressed_keys, triggered, "FN"),
+            razer_key_pressed(pressed_keys, triggered, "LEFTMETA"),
+        )
+
+        if released_modifier_keys(
+            leftmeta_released=not razer_key_pressed(
+                pressed_keys, triggered, "LEFTMETA"
+            ),
+            leftmeta_in_repeat=evdev.ecodes.ecodes["KEY_LEFTMETA"] in repeat,
+            fn_released=not razer_key_pressed(pressed_keys, triggered, "FN"),
+            fn_in_repeat=evdev.ecodes.ecodes["KEY_FN"] in repeat,
+        ):
+            for code in repeat:
+                await user_input_queue.put((evdev.ecodes.ecodes["EV_KEY"], code, 0))
+            repeat = {}
+
+        for pressed_key, value in pressed_keys.items():
+            if pressed_key in razer_analog.layout.layout_analog:
+                await user_input_queue.put(
+                    (
+                        evdev.ecodes.ecodes["EV_ABS"],
+                        razer_analog.layout.layout_analog[pressed_key][0],
+                        value,
+                    )
+                )
+
+            if not pressed_key in layout:
+                # ignore pressed_keys not in layout (ie. released keys)
+                continue
+
+            code = layout[pressed_key]
+
+            if key_triggered(triggered, pressed_key, value):
+                if not code in repeat:
+                    repeat[code] = time.monotonic() + 0.2
+                    await user_input_queue.put((evdev.ecodes.ecodes["EV_KEY"], code, 1))
+            elif code != evdev.ecodes.ecodes["KEY_FN"] and code in repeat:
+                # Handle untrigger of key
+                # Fn key release is handled above
+                del repeat[code]
+                await user_input_queue.put((evdev.ecodes.ecodes["EV_KEY"], code, 0))
+
+
+def main() -> None:
+    """
+    Setup queues and await:
+     - unix_service (for control messages)
+     - receive pressed keys
+     - handle virtual keyboard
+     - write to user input queue
+    """
+    loop = asyncio.get_event_loop()
+
+    pressed_queue: asyncio.Queue[typing.Dict[int, int]] = asyncio.Queue()
+    user_input_queue: asyncio.Queue[typing.Tuple[int, int, int]] = asyncio.Queue()
+
+    user_input_keyb = evdev.UInput(
+        {
+            evdev.ecodes.ecodes["EV_KEY"]: list(
+                razer_analog.layout.layout["plain"].values()
+            )
+            + list(razer_analog.layout.layout["fn"].values())
+            + list(razer_analog.layout.layout["fn_fn"].values()),
+            evdev.ecodes.ecodes["EV_ABS"]: list(
+                razer_analog.layout.layout_analog.values()
+            ),
+        },
+        name=f"razer-analog-keyboard-{os.getpid()}",
+    )
+
+    # Run: udevadm info -t
+    # Search for: Razer_Huntsman_Mini_Analog
+    # Check for "T: usb_device", use (P:):
+    # /sys/devices/pci0000:00/0000:00:14.0/usb3/3-1
+    parent = sys.argv[1]
+    razer_huntsman_mini = HuntsmanMiniAnalog(pressed_queue, parent)
+
+    def shutdown() -> None:
+        razer_huntsman_mini.set_device_mode(0)
+        razer_huntsman_mini.close()
+        os.unlink(f"/var/run/razer-analog-{os.getpid()}")
+
+    atexit.register(shutdown)
+
+    razer_huntsman_mini.set_device_mode(3)
+
+    tasks = asyncio.gather(
+        razer_huntsman_mini.unix_server(),
+        razer_huntsman_mini.run(),
+        virtual_keyboard(pressed_queue, user_input_queue),
+        user_input_write(user_input_keyb, user_input_queue),
+    )
+
+    loop.add_signal_handler(signal.SIGTERM, tasks.cancel)
+    loop.run_until_complete(tasks)

razer_analog-0.1.0/razer_analog/hidraw.py

@@ -0,0 +1,138 @@
+import ctypes
+import collections
+import fcntl
+import ioctl_opt
+
+# input.h
+BUS_USB = 0x03
+BUS_HIL = 0x04
+BUS_BLUETOOTH = 0x05
+BUS_VIRTUAL = 0x06
+
+# hid.h
+_HID_MAX_DESCRIPTOR_SIZE = 4096
+
+# hidraw.h
+class _hidraw_report_descriptor(ctypes.Structure):
+    _fields_ = [
+        ("size", ctypes.c_uint),
+        ("value", ctypes.c_ubyte * _HID_MAX_DESCRIPTOR_SIZE),
+    ]
+
+
+class _hidraw_devinfo(ctypes.Structure):
+    _fields_ = [
+        ("bustype", ctypes.c_uint),
+        ("vendor", ctypes.c_short),
+        ("product", ctypes.c_short),
+    ]
+
+
+_HIDIOCGRDESCSIZE = ioctl_opt.IOR(ord("H"), 0x01, ctypes.c_int)
+_HIDIOCGRDESC = ioctl_opt.IOR(ord("H"), 0x02, _hidraw_report_descriptor)
+_HIDIOCGRAWINFO = ioctl_opt.IOR(ord("H"), 0x03, _hidraw_devinfo)
+_HIDIOCGRAWNAME = lambda len: ioctl_opt.IOC(ioctl_opt.IOC_READ, ord("H"), 0x04, len)
+_HIDIOCGRAWPHYS = lambda len: ioctl_opt.IOC(ioctl_opt.IOC_READ, ord("H"), 0x05, len)
+_HIDIOCSFEATURE = lambda len: ioctl_opt.IOC(
+    ioctl_opt.IOC_WRITE | ioctl_opt.IOC_READ, ord("H"), 0x06, len
+)
+_HIDIOCGFEATURE = lambda len: ioctl_opt.IOC(
+    ioctl_opt.IOC_WRITE | ioctl_opt.IOC_READ, ord("H"), 0x07, len
+)
+
+HIDRAW_FIRST_MINOR = 0
+HIDRAW_MAX_DEVICES = 64
+HIDRAW_BUFFER_SIZE = 64
+
+DevInfo = collections.namedtuple("DevInfo", ["bustype", "vendor", "product"])
+
+
+class HIDRaw(object):
+    """
+    Provides methods to access hidraw device's ioctls.
+    """
+
+    def __init__(self, device):
+        """
+        device (file, fileno)
+            A file object or a fileno of an open hidraw device node.
+        """
+        self._device = device
+
+    def _ioctl(self, func, arg, mutate_flag=False):
+        result = fcntl.ioctl(self._device, func, arg, mutate_flag)
+        if result < 0:
+            raise IOError(result)
+
+    def getRawReportDescriptor(self):
+        """
+        Return a binary string containing the raw HID report descriptor.
+        """
+        descriptor = _hidraw_report_descriptor()
+        size = ctypes.c_uint()
+        self._ioctl(_HIDIOCGRDESCSIZE, size, True)
+        descriptor.size = size
+        self._ioctl(_HIDIOCGRDESC, descriptor, True)
+        return descriptor.value[: size.value]
+
+    # TODO: decode descriptor into a python object
+    # def getReportDescriptor(self):
+
+    def getInfo(self):
+        """
+        Returns a DevInfo instance, a named tuple with the following items:
+        - bustype: one of BUS_USB, BUS_HIL, BUS_BLUETOOTH or BUS_VIRTUAL
+        - vendor: device's vendor number
+        - product: device's product number
+        """
+        devinfo = _hidraw_devinfo()
+        self._ioctl(_HIDIOCGRAWINFO, devinfo, True)
+        return DevInfo(devinfo.bustype, devinfo.vendor, devinfo.product)
+
+    def getName(self, length=512):
+        """
+        Returns device name as an unicode object.
+        """
+        name = ctypes.create_string_buffer(length)
+        self._ioctl(_HIDIOCGRAWNAME(length), name, True)
+        return name.value.decode("UTF-8")
+
+    def getPhysicalAddress(self, length=512):
+        """
+        Returns device physical address as a string.
+        See hidraw documentation for value signification, as it depends on
+        device's bus type.
+        """
+        name = ctypes.create_string_buffer(length)
+        self._ioctl(_HIDIOCGRAWPHYS(length), name, True)
+        return name.value
+
+    def sendFeatureReport(self, report, report_num=0):
+        """
+        Send a feature report.
+        """
+        length = len(report) + 1
+        buf = bytearray(length)
+        buf[0] = report_num
+        buf[1:] = report
+        self._ioctl(
+            _HIDIOCSFEATURE(length),
+            (ctypes.c_char * length).from_buffer(buf),
+            True,
+        )
+
+    def getFeatureReport(self, report_num=0, length=63):
+        """
+        Receive a feature report.
+        Blocks, unless you configured provided file (descriptor) to be
+        non-blocking.
+        """
+        length += 1
+        buf = bytearray(length)
+        buf[0] = report_num
+        self._ioctl(
+            _HIDIOCGFEATURE(length),
+            (ctypes.c_char * length).from_buffer(buf),
+            True,
+        )
+        return buf

razer_analog-0.1.0/razer_analog/hidrawtests.py

@@ -0,0 +1,86 @@
+import sys
+import os
+import razer_analog.hidraw
+import pyudev
+import struct
+
+
+def crc(buf: bytes) -> int:
+    """
+    Calculate Razer CRC
+    """
+    result = 0
+    for i in range(2, 86):
+        result ^= buf[i]
+    return result
+
+
+def razer_command(hidraw, data: bytes) -> None:
+    """
+    Send a razer command
+    """
+    send_report = struct.pack(
+        ">BBHBB",
+        0x00,  # status
+        0xFF,  # transaction_id
+        0x00,  # remaining_packets
+        0x00,  # protocol_type
+        len(data) - 2,  # size
+    )
+    send_report += data
+    send_report += b"\x00" * (82 - len(data))
+    send_report += bytes([crc(send_report)])
+    send_report += b"\x00"
+
+    hidraw.sendFeatureReport(send_report)
+    received_report = hidraw.getFeatureReport(0, 90)
+
+    if received_report[1] == 0x02:  # SUCCESS
+        if received_report[2:] != send_report[1:]:
+            print("mismatched received_report != send_report")
+            print(received_report)
+            print(send_report)
+    else:
+        print("failed to send_report")
+        print(send_report)
+
+
+def main():
+    context = pyudev.Context()
+    parent = pyudev.Devices.from_path(context, sys.argv[1])
+    for udev in context.list_devices(parent=parent, subsystem="hidraw"):
+        device_handle = open(udev.device_node, "rb")
+        os.set_blocking(device_handle.fileno(), False)
+        hidraw = razer_analog.hidraw.HIDRaw(device_handle)
+        i = hidraw.getInfo()
+        if i.vendor == 0x1532 and i.product == 0x0282:
+            desc = hidraw.getRawReportDescriptor()
+            print(desc)
+            if list(desc) == [
+                5,
+                12,
+                9,
+                1,
+                161,
+                1,
+                6,
+                0,
+                255,
+                9,
+                2,
+                21,
+                0,
+                37,
+                1,
+                117,
+                8,
+                149,
+                90,
+                177,
+                1,
+                192,
+            ]:
+                print("found")
+                break
+        device_handle.close()
+    razer_command(hidraw, bytes((3, 0x00)))

razer_analog-0.1.0/razer_analog/layout.py

@@ -0,0 +1,56 @@
+"""
+Layout for keyboard
+"""
+import typing
+import json
+import pkg_resources  # type: ignore
+import evdev  # type: ignore
+
+absinfo = evdev.device.AbsInfo(value=0, min=0, max=255, fuzz=0, flat=0, resolution=1)
+layout_analog = {
+    36: (evdev.ecodes.ecodes["ABS_HAT0X"], absinfo),
+    37: (evdev.ecodes.ecodes["ABS_HAT0Y"], absinfo),
+    38: (evdev.ecodes.ecodes["ABS_HAT1X"], absinfo),
+    39: (evdev.ecodes.ecodes["ABS_HAT1Y"], absinfo),
+    18: (evdev.ecodes.ecodes["ABS_HAT2X"], absinfo),
+    47: (evdev.ecodes.ecodes["ABS_HAT2Y"], absinfo),
+}
+
+
+def load_layout() -> typing.Dict[str, typing.Dict[int, int]]:
+    """
+    Load layout from json file
+    """
+    with open(
+        pkg_resources.resource_filename(
+            "razer_analog", "razer_huntsman_mini_analog.json"
+        ),
+        encoding="utf-8",
+    ) as razer_huntsman_mini_analog_file:
+        result: typing.Dict[str, typing.Dict[int, int]] = {
+            "plain": {},
+            "fn": {},
+            "fn_fn": {},
+        }
+        for layout_key, layout_value in json.load(
+            razer_huntsman_mini_analog_file
+        ).items():
+            for razer_key, evdev_key in layout_value.items():
+                result[layout_key][int(razer_key)] = evdev.ecodes.ecodes[
+                    "KEY_" + evdev_key
+                ]
+    return result
+
+
+layout = load_layout()
+
+
+def get_layout(fn_pressed: bool, meta_pressed: bool) -> typing.Dict[int, int]:
+    """
+    Get layout from pressed keys
+    """
+    if fn_pressed and meta_pressed:
+        return layout["fn_fn"]
+    if fn_pressed or meta_pressed:
+        return layout["fn"]
+    return layout["plain"]

razer_analog-0.1.0/razer_analog/mouse.py

@@ -0,0 +1,419 @@
+"""
+Razer Ananlog virtual mouse
+"""
+import asyncio
+import collections
+import atexit
+import time
+import colorsys
+import socket
+import signal
+import sys
+import typing
+import os.path
+
+import evdev  # type: ignore
+import pyudev  # type: ignore
+
+
+class Mouse:
+    """
+    Virtual Mouse
+    """
+
+    def __init__(self, state: typing.Dict[int, collections.defaultdict[int, int]]):
+        self.ui_mouse = evdev.UInput(
+            evdev.util.find_ecodes_by_regex(
+                r"(REL_X|REL_Y|REL_WHEEL|REL_WHEEL_HI_RES|"
+                r"BTN_RIGHT|BTN_MIDDLE|BTN_LEFT|KEY_CAPSLOCK)$"
+            )
+        )
+        self.enabled: bool = False
+        self.state: typing.Dict[int, collections.defaultdict[int, int]] = state
+
+    def enable(self) -> None:
+        """
+        Enable mouse
+        """
+        self.enabled = True
+
+    def disable(self) -> None:
+        """
+        Disable mouse
+        """
+        self.enabled = False
+
+    def handle(self, from_event: int, to_event: int, direction: int) -> None:
+        """
+        Handle event
+        """
+        value = self.state[evdev.ecodes.ecodes["EV_ABS"]][from_event]
+
+        if value:
+            value = 0.000000000749 * pow(value, 4.5) + 1
+            self.ui_mouse.write(
+                evdev.ecodes.ecodes["EV_REL"], to_event, int(value) * direction
+            )
+
+    def write(self, typ: int, code: int, value: int) -> None:
+        """
+        Write event
+        """
+        self.ui_mouse.write(typ, code, value)
+
+    async def run(self) -> None:
+        """
+        Main loop
+        """
+        while True:
+            if self.enabled:
+                await asyncio.sleep(0.05)
+                self.handle(evdev.ecodes.ABS_HAT0X, evdev.ecodes.REL_X, -1)
+                self.handle(evdev.ecodes.ABS_HAT0Y, evdev.ecodes.REL_Y, 1)
+                self.handle(evdev.ecodes.ABS_HAT1X, evdev.ecodes.REL_Y, -1)
+                self.handle(evdev.ecodes.ABS_HAT1Y, evdev.ecodes.REL_X, 1)
+                value = self.state[evdev.ecodes.EV_ABS][evdev.ecodes.ABS_HAT2Y]
+                if value:
+                    self.ui_mouse.write(
+                        evdev.ecodes.EV_REL,
+                        evdev.ecodes.REL_WHEEL_HI_RES,
+                        int(value) * -1,
+                    )
+                    self.ui_mouse.write(evdev.ecodes.EV_REL, evdev.ecodes.REL_WHEEL, -1)
+                value = self.state[evdev.ecodes.EV_ABS][evdev.ecodes.ABS_HAT2X]
+                if value:
+                    self.ui_mouse.write(
+                        evdev.ecodes.EV_REL,
+                        evdev.ecodes.REL_WHEEL_HI_RES,
+                        int(value) * 1,
+                    )
+                    self.ui_mouse.write(evdev.ecodes.EV_REL, evdev.ecodes.REL_WHEEL, 1)
+
+                self.ui_mouse.syn()
+            else:
+                await asyncio.sleep(0.1)
+
+
+class Chroma:
+    """
+    Chroma lighting
+    """
+
+    def __init__(self, razer_analog_pid: int):
+        sock_file = f"/var/run/razer-analog-{razer_analog_pid}"
+        for _ in range(10):
+            if os.path.exists(sock_file):
+                break
+            time.sleep(0.1)
+
+        self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self.sock.connect(sock_file)
+        self.sock.settimeout(1)
+        # custom
+        self.do_time_of_day = True
+        self.brightness = 0xFF
+        self.time_of_day()
+
+    def custom_frame(
+        self, row: int, start: int, data: typing.Tuple[typing.Tuple[int, int, int], ...]
+    ) -> bytes:
+        """
+        Enable custom frame mode (so we can manually enable LEDs)
+        """
+        result = b"\x0f\x03\x00\x00"
+        result += bytes((row, start, start + len(data) - 1))
+        for rgb in data:
+            result += bytes(rgb)
+        return result
+
+    def send(self, data: bytes) -> None:
+        """
+        Send data using simple protocol (len + data)
+        """
+        try:
+            self.sock.sendall(bytes((len(data),)) + data)
+        except BrokenPipeError as exception:
+            print("failed to send", exception)
+
+        if not data:
+            return
+
+        pktlen = self.sock.recv(1)
+
+        received_data = self.sock.recv(pktlen[0])[7 : 7 + len(data)]
+        if received_data != data:
+            print("received_data != data", received_data, data)
+
+    def times255(
+        self, rgb: typing.Tuple[float, float, float]
+    ) -> typing.Tuple[int, int, int]:
+        """
+        Multiply RGB set by 255
+        """
+        return int(rgb[0] * 0xFF), int(rgb[1] * 0xFF), int(rgb[2] * 0xFF)
+
+    def mouse(self) -> None:
+        """
+        Enable custom frame for mouse mode
+        """
+        self.do_time_of_day = False
+        self.send(self.custom_frame(0, 0, ((0xFF, 0xFF, 0xFF),) * 1))
+        self.send(self.custom_frame(0, 1, ((0, 0, 0),) * 14))
+
+        self.send(self.custom_frame(1, 0, ((0, 0, 0),) * 2))
+        self.send(self.custom_frame(1, 2, ((0xFF, 0xFF, 0xFF),) * 1))
+        self.send(self.custom_frame(1, 3, ((0, 0, 0),) * 12))
+
+        self.send(self.custom_frame(2, 0, ((0xFF, 0xFF, 0xFF),) * 4))
+        self.send(self.custom_frame(2, 4, ((0, 0, 0),) * 2))
+        self.send(self.custom_frame(2, 6, ((0xFF, 0xFF, 0xFF),) * 4))
+        self.send(self.custom_frame(2, 10, ((0, 0, 0),) * 5))
+
+        self.send(self.custom_frame(3, 0, ((0, 0, 0),) * 3))
+        self.send(self.custom_frame(3, 3, ((0xFF, 0xFF, 0xFF),) * 1))
+        self.send(self.custom_frame(3, 4, ((0, 0, 0),) * 11))
+
+        self.send(self.custom_frame(4, 0, ((0, 0, 0),) * 15))
+
+    def time_of_day(self) -> None:
+        """
+        Enable custom frame for time of day mode
+        """
+        self.do_time_of_day = True
+        self.send(b"\x0f\x02\x00\x05\x08")
+        localtime = time.localtime()
+        hue = (localtime.tm_hour * 60 + localtime.tm_min) / (24 * 60)
+        for row in range(5):
+            self.send(
+                self.custom_frame(
+                    row, 0, (self.times255(colorsys.hls_to_rgb(hue, 0.5, 1)),) * 15
+                )
+            )
+
+    def highlight_fn(self) -> None:
+        """
+        Highlight buttons that can be used with fn
+        """
+        self.send(self.custom_frame(0, 0, ((0xFF, 0xFF, 0xFF),) * 15))
+
+        self.send(self.custom_frame(1, 0, ((0xFF, 0xFF, 0xFF),) * 13))
+        self.send(self.custom_frame(1, 13, ((0x00, 0x00, 0x00),) * 2))
+
+        self.send(self.custom_frame(2, 0, ((0x00, 0x00, 0x00),) * 5))
+        self.send(self.custom_frame(2, 5, ((0xFF, 0xFF, 0xFF),) * 7))
+        self.send(self.custom_frame(2, 12, ((0x00, 0x00, 0x00),) * 3))
+
+        self.send(self.custom_frame(3, 0, ((0x00, 0x00, 0x00),) * 9))
+        self.send(self.custom_frame(3, 9, ((0xFF, 0xFF, 0xFF),) * 3))
+        self.send(self.custom_frame(3, 12, ((0x00, 0x00, 0x00),) * 3))
+
+        self.send(self.custom_frame(4, 0, ((0x00, 0x00, 0x00),) * 15))
+
+    def highlight_shift(self) -> None:
+        """
+        Highlight buttons that can be used with shift
+        """
+        self.send(self.custom_frame(0, 0, ((0x00, 0x00, 0x00),) * 1))
+        self.send(self.custom_frame(0, 1, ((0xFF, 0xFF, 0xFF),) * 13))
+        self.send(self.custom_frame(0, 14, ((0x00, 0x00, 0x00),) * 1))
+
+        self.send(self.custom_frame(1, 0, ((0xFF, 0xFF, 0xFF),) * 15))
+
+        self.send(self.custom_frame(2, 0, ((0x00, 0x00, 0x00),) * 1))
+        self.send(self.custom_frame(2, 1, ((0xFF, 0xFF, 0xFF),) * 14))
+
+        self.send(self.custom_frame(3, 0, ((0x00, 0x00, 0x00),) * 1))
+        self.send(self.custom_frame(3, 1, ((0xFF, 0xFF, 0xFF),) * 11))
+        self.send(self.custom_frame(3, 12, ((0x00, 0x00, 0x00),) * 3))
+
+        self.send(self.custom_frame(4, 0, ((0x00, 0x00, 0x00),) * 15))
+
+    def highlight_shift_fn(self) -> None:
+        """
+        Highlight buttons that can be used with shift-fn
+        """
+        self.send(self.custom_frame(0, 0, ((0xFF, 0xFF, 0xFF),) * 15))
+
+        self.send(self.custom_frame(1, 0, ((0x00, 0x00, 0x00),) * 8))
+        self.send(self.custom_frame(1, 8, ((0xFF, 0xFF, 0xFF),) * 5))
+        self.send(self.custom_frame(1, 13, ((0x00, 0x00, 0x00),) * 2))
+
+        self.send(self.custom_frame(2, 0, ((0x00, 0x00, 0x00),) * 7))
+        self.send(self.custom_frame(2, 7, ((0xFF, 0xFF, 0xFF),) * 5))
+        self.send(self.custom_frame(2, 12, ((0x00, 0x00, 0x00),) * 3))
+
+        self.send(self.custom_frame(3, 0, ((0x00, 0x00, 0x00),) * 11))
+        self.send(self.custom_frame(3, 11, ((0xFF, 0xFF, 0xFF),) * 1))
+        self.send(self.custom_frame(3, 12, ((0x00, 0x00, 0x00),) * 3))
+
+        self.send(self.custom_frame(4, 0, ((0x00, 0x00, 0x00),) * 15))
+
+    def adjust_brightness(self, offset: int) -> None:
+        """
+        Adjust brightness of LEDs
+        """
+        self.brightness += offset
+        self.brightness = min(max(self.brightness, 0), 0xFF)
+        self.send(b"\x0f\x04\x00\x00" + bytes((self.brightness,)))
+
+    async def run(self) -> None:
+        """
+        Main loop
+        """
+        while 1:
+            await asyncio.sleep(60)
+            if self.do_time_of_day:
+                self.time_of_day()
+
+
+async def keyboard(
+    razer_analog_keyboard: evdev.InputDevice,
+    state: typing.Dict[int, collections.defaultdict[int, int]],
+    mouse: Mouse,
+    chroma: Chroma,
+) -> None:
+    """
+    Watch keyboard events
+    """
+    shift_pressed = False
+    fn_pressed = False
+    try:
+        async for event in razer_analog_keyboard.async_read_loop():
+            state[event.type][event.code] = event.value
+
+            if mouse.enabled:
+                if (
+                    event.type == evdev.ecodes.ecodes["EV_KEY"]
+                    and event.code == evdev.ecodes.ecodes["KEY_CAPSLOCK"]
+                ):
+                    mouse.write(
+                        evdev.ecodes.ecodes["EV_KEY"],
+                        evdev.ecodes.ecodes["KEY_CAPSLOCK"],
+                        event.value,
+                    )
+                if (
+                    event.type == evdev.ecodes.ecodes["EV_KEY"]
+                    and event.code == evdev.ecodes.ecodes["KEY_A"]
+                ):
+                    mouse.write(
+                        evdev.ecodes.ecodes["EV_KEY"],
+                        evdev.ecodes.ecodes["BTN_LEFT"],
+                        event.value,
+                    )
+                if (
+                    event.type == evdev.ecodes.ecodes["EV_KEY"]
+                    and event.code == evdev.ecodes.ecodes["KEY_S"]
+                ):
+                    mouse.write(
+                        evdev.ecodes.ecodes["EV_KEY"],
+                        evdev.ecodes.ecodes["BTN_MIDDLE"],
+                        event.value,
+                    )
+                if (
+                    event.type == evdev.ecodes.ecodes["EV_KEY"]
+                    and event.code == evdev.ecodes.ecodes["KEY_D"]
+                ):
+                    mouse.write(
+                        evdev.ecodes.ecodes["EV_KEY"],
+                        evdev.ecodes.ecodes["BTN_RIGHT"],
+                        event.value,
+                    )
+                if (
+                    event.type == evdev.ecodes.ecodes["EV_KEY"]
+                    and event.code == evdev.ecodes.ecodes["KEY_ESC"]
+                ):
+                    mouse.disable()
+                    chroma.time_of_day()
+                    razer_analog_keyboard.ungrab()
+            else:
+                if (
+                    event.type == evdev.ecodes.ecodes["EV_KEY"]
+                    and event.code == evdev.ecodes.ecodes["KEY_KEYBOARD"]
+                    and event.value
+                ):
+                    chroma.mouse()
+                    while razer_analog_keyboard.active_keys():
+                        await asyncio.sleep(0.1)
+                    # fingers crossed no keys are pressed..
+                    razer_analog_keyboard.grab()
+
+                    mouse.enable()
+                elif (
+                    event.type == evdev.ecodes.ecodes["EV_KEY"]
+                    and event.code == evdev.ecodes.ecodes["KEY_FN"]
+                ):
+                    if event.value:
+                        fn_pressed = True
+                        if shift_pressed:
+                            chroma.highlight_shift_fn()
+                        else:
+                            chroma.highlight_fn()
+                    else:
+                        fn_pressed = False
+                        chroma.time_of_day()
+
+                elif event.type == evdev.ecodes.ecodes["EV_KEY"] and event.code in (
+                    evdev.ecodes.ecodes["KEY_LEFTSHIFT"],
+                    evdev.ecodes.ecodes["KEY_RIGHTSHIFT"],
+                ):
+                    if event.value:
+                        if fn_pressed:
+                            chroma.highlight_shift_fn()
+                        else:
+                            chroma.highlight_shift()
+
+                        shift_pressed = True
+                    else:
+                        chroma.time_of_day()
+                        shift_pressed = False
+                elif (
+                    event.type == evdev.ecodes.ecodes["EV_KEY"]
+                    and event.code == evdev.ecodes.ecodes["KEY_KBDILLUMDOWN"]
+                ):
+                    chroma.adjust_brightness(-0x0F)
+                elif (
+                    event.type == evdev.ecodes.ecodes["EV_KEY"]
+                    and event.code == evdev.ecodes.ecodes["KEY_KBDILLUMUP"]
+                ):
+                    chroma.adjust_brightness(0x0F)
+
+    except OSError as exception:
+        print(exception, "exiting")
+        sys.exit()
+
+
+def main() -> None:
+    """
+    Main loop
+    """
+    context = pyudev.Context()
+    # run: udevadm info -t
+    # search for "razer-analog-keyboard-"
+    # Use the child of this device (event*) (P:):
+    # /sys/devices/virtual/input/input39/event23
+    udev = pyudev.Devices.from_path(context, sys.argv[1])
+    razer_analog_keyboard = evdev.InputDevice(udev.device_node)
+
+    razer_analog_pid = razer_analog_keyboard.name.split("-")[-1]
+    print(razer_analog_keyboard)
+
+    state: typing.Dict[int, collections.defaultdict[int, int]] = {
+        evdev.ecodes.ecodes["EV_SYN"]: collections.defaultdict(int),
+        evdev.ecodes.ecodes["EV_ABS"]: collections.defaultdict(int),
+        evdev.ecodes.ecodes["EV_KEY"]: collections.defaultdict(int),
+    }
+    mouse = Mouse(state)
+    chroma = Chroma(razer_analog_pid)
+
+    tasks = asyncio.gather(
+        mouse.run(), keyboard(razer_analog_keyboard, state, mouse, chroma), chroma.run()
+    )
+
+    loop = asyncio.get_event_loop()
+    loop.add_signal_handler(signal.SIGTERM, tasks.cancel)
+
+    def shutdown() -> None:
+        chroma.send(b"")
+
+    atexit.register(shutdown)
+    loop.run_until_complete(tasks)

razer_analog-0.1.0/razer_analog/razer_huntsman_mini_analog.json

@@ -0,0 +1,19 @@
+{
+    "plain": {
+        "110": "ESC", "2": "1", "3": "2", "4": "3", "5": "4", "6": "5", "7": "6", "8": "7", "9": "8", "10": "9", "11": "0", "12": "MINUS", "13": "EQUAL", "15": "BACKSPACE",
+        "16": "TAB", "17": "Q", "18": "W", "19": "E", "20": "R", "21": "T", "22": "Y", "23": "U", "24": "I", "25": "O", "26": "P", "27": "LEFTBRACE", "28": "RIGHTBRACE", "29": "BACKSLASH",
+        "30": "CAPSLOCK", "31": "A", "32": "S", "33": "D", "34": "F", "35": "G", "36": "H", "37": "J", "38": "K", "39": "L", "40": "SEMICOLON", "41": "APOSTROPHE", "43": "ENTER",
+        "44": "LEFTSHIFT", "46": "Z", "47": "X", "48": "C", "49": "V", "50": "B", "51": "N", "52": "M", "53": "COMMA", "54": "DOT", "55": "SLASH", "57": "RIGHTSHIFT",
+        "58": "LEFTCTRL", "127": "LEFTMETA", "60": "LEFTALT", "61": "SPACE", "62": "RIGHTALT", "59": "FN", "129": "COMPOSE", "64": "RIGHTCTRL"
+    },
+    "fn": {
+        "110": "GRAVE", "2": "F1", "3": "F2", "4": "F3", "5": "F4", "6": "F5", "7": "F6", "8": "F7", "9": "F8", "10": "F9", "11": "F10", "12": "F11", "13": "F12", "15": "DELETE",
+        "16": "MUTE", "17": "VOLUMEDOWN", "18": "VOLUMEUP", "19": "REWIND", "20": "PLAYPAUSE", "21": "FASTFORWARD", "24": "UP", "25": "SCROLLLOCK", "26": "SYSRQ", "27": "PAGEUP", "28": "HOME",
+        "30": "CAPSLOCK", "35": "KBDILLUMDOWN", "36": "KBDILLUMUP","37": "LEFT", "38": "DOWN", "39": "RIGHT", "40": "PAGEDOWN", "41": "END", "43": "KEYBOARD",
+        "44": "LEFTSHIFT", "53": "SLEEP", "54": "PAUSE", "55": "INSERT", "57": "RIGHTSHIFT",
+        "58": "LEFTCTRL", "127": "FN", "60": "LEFTALT", "62": "RIGHTALT", "59": "FN", "64": "RIGHTCTRL"
+    },
+    "fn_fn": {
+        "127": "LEFTMETA", "59": "FN"
+    }
+}

razer_analog-0.1.0/razer_analog/razerctl.py

@@ -0,0 +1,165 @@
+import socket
+import time
+import colorsys
+import glob
+import random
+import typing
+import atexit
+
+
+def times255(
+    self, rgb: typing.Tuple[float, float, float]
+) -> typing.Tuple[int, int, int]:
+    """
+    Multiply RGB set by 255
+    """
+    return int(rgb[0] * 0xFF), int(rgb[1] * 0xFF), int(rgb[2] * 0xFF)
+
+
+def custom_frame(row, start, data):
+    result = b"\x0f\x03\x00\x00"
+    result += bytes((row, start, start + len(data) - 1))
+    for rgb in data:
+        result += bytes(rgb)
+    return result
+
+
+def times255(rgb):
+    return int(rgb[0] * 0xFF), int(rgb[1] * 0xFF), int(rgb[2] * 0xFF)
+
+
+class RazerCtl:
+    def __init__(self):
+        self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self.sock.connect(glob.glob("/var/run/razer-analog-*")[0])
+
+    def send(self, data):
+        self.sock.sendall(bytes((len(data),)) + data)
+
+        if not data:
+            return
+
+        pktlen = self.sock.recv(1)
+        received_data = self.sock.recv(pktlen[0])[7 : 7 + len(data)]
+
+        print("received_data, data", received_data, data)
+
+        return received_data
+
+
+def main():
+    razerctl = RazerCtl()
+
+    # wave
+    # razerctl.send("\x0f\x02\x01\x05\x04\x01\x20")
+
+    # spectrum cycle
+    # razerctl.send("\x0f\x02\x01\x05\x03")
+
+    # custom
+    if False:
+        razerctl.send(b"\x0f\x02\x00\x00\x08")
+
+    # custom frame
+    if False:
+        t = time.localtime()
+        y = (t.tm_hour * 60 + t.tm_min) / (24 * 60)
+        razerctl.send(
+            custom_frame(0, 0, (times255(colorsys.hls_to_rgb(y, 0.5, 1)),) * 15)
+        )
+        razerctl.send(
+            custom_frame(1, 0, (times255(colorsys.hls_to_rgb(y, 0.5, 1)),) * 15)
+        )
+        razerctl.send(
+            custom_frame(2, 0, (times255(colorsys.hls_to_rgb(y, 0.5, 1)),) * 15)
+        )
+        razerctl.send(
+            custom_frame(3, 0, (times255(colorsys.hls_to_rgb(y, 0.5, 1)),) * 15)
+        )
+        razerctl.send(
+            custom_frame(4, 0, (times255(colorsys.hls_to_rgb(y, 0.5, 1)),) * 15)
+        )
+    if False:
+        razerctl.send(custom_frame(0, 0, ((0xFF, 0xFF, 0xFF),) * 1))
+        razerctl.send(custom_frame(0, 1, ((0, 0, 0),) * 14))
+
+        razerctl.send(custom_frame(1, 0, ((0, 0, 0),) * 2))
+        razerctl.send(custom_frame(1, 2, ((0xFF, 0xFF, 0xFF),) * 1))
+        razerctl.send(custom_frame(1, 3, ((0, 0, 0),) * 12))
+
+        razerctl.send(custom_frame(2, 0, ((0, 0, 0),) * 1))
+        razerctl.send(custom_frame(2, 1, ((0xFF, 0xFF, 0xFF),) * 3))
+        razerctl.send(custom_frame(2, 4, ((0, 0, 0),) * 2))
+        razerctl.send(custom_frame(2, 6, ((0xFF, 0xFF, 0xFF),) * 4))
+
+        razerctl.send(custom_frame(3, 0, ((0, 0, 0),) * 3))
+        razerctl.send(custom_frame(3, 3, ((0xFF, 0xFF, 0xFF),) * 1))
+        razerctl.send(custom_frame(3, 4, ((0, 0, 0),) * 12))
+
+        razerctl.send(custom_frame(4, 0, ((0, 0, 0),) * 15))
+
+    if False:
+        # brightness
+        razerctl.send(b"\x0f\x04\x00\x00\xFF")
+
+    if False:
+        # Get layout / ping
+        razerctl.send(b"\x00\x86\x00\x00")
+
+    if False:
+        # Device mode
+        razerctl.send(b"\x00\x04\x03\x00")
+
+    if False:
+        razerctl.send(b"\x05\x8A\x00")
+        razerctl.send(b"\x05\x03\x1d")
+        razerctl.send(b"\x06\x80\x00\x00")
+        # memory stats
+        # razerctl.send(b"\x06\x8e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
+
+        # razerctl.send(b"\x05\x80\x00")
+        # razerctl.send(b"\x00\x87\x00")
+        # razerctl.send(b"\x05\x88\x00\x00\x00\x00\xfa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
+        # razerctl.send(b"\x05\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
+        # razerctl.send(b"\x0f\x82\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
+        # razerctl.send(b"\x02\x12\x01\x11\x00\x00\x00\x02\x02\x00\x17\x00\x00\x00")
+        # razerctl.send(b"\x02\x12\x05\x11\x00\x00\x00\x02\x02\x00\x05\x00\x00\x00")
+        # razerctl.send(b"\x02\x12\x01\x11\x00\x00\x00\x02\x02\x00\x14\x00\x00\x00")
+        pass
+    if True:
+        # left meta = fn
+        razerctl.send(b"\x02\x12\x01\x7f\x00\x00\x00\x0c\x01\x01\x00\x00\x00\x00")
+        razerctl.send(b"\x02\x12\x01\x7f\x01\x00\x00\x0c\x01\x01\x00\x00\x00\x00")
+
+        razerctl.send(b"\x02\x12\x02\x7f\x00\x00\x00\x0c\x01\x01\x00\x00\x00\x00")
+        razerctl.send(b"\x02\x12\x02\x7f\x01\x00\x00\x0c\x01\x01\x00\x00\x00\x00")
+    if False:
+        # Read presets
+        razerctl.send(
+            b"\x05\x88\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+        )
+        razerctl.send(
+            b"\x05\x88\x02\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+        )
+        razerctl.send(
+            b"\x05\x88\x02\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+        )
+        razerctl.send(
+            b"\x05\x88\x02\x00\xc0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+        )
+
+    while False:
+        for row in range(5):
+            randoms = []
+            for i in range(15):
+                randoms.append(
+                    times255(colorsys.hls_to_rgb(random.uniform(0, 1), 0.5, 1))
+                )
+            razerctl.send(custom_frame(row, 0, randoms))
+        time.sleep(0.1)
+
+    def shutdown() -> None:
+        razerctl.send(b"")
+
+    atexit.register(shutdown)
+    # sock.sendall(b"\x0f\x02\x01\x05\x03")