Obteniendo claves macro de un Razer BlackWidow para trabajar en Linux

Elegí un Razer BlackWidow Ultimate que tiene claves adicionales destinadas a macros que se configuran con una herramienta instalada en Windows . Supongo que estas no son algunas claves joojoo de fantasía y deberían emitir códigos de escaneo como cualquier otra clave.

En primer lugar, ¿hay una forma estándar de verificar estos códigos de escaneo en Linux? En segundo lugar, ¿cómo configuro estas teclas para hacer cosas en la línea de comandos y configuraciones de Linux basadas en X? Mi instalación actual de Linux es Xubuntu 10.10, pero cambiaré a Kubuntu una vez que tenga algunas cosas arregladas. Idealmente, la respuesta debería ser genérica y de todo el sistema.

Cosas que he probado hasta ahora:

• showkeys desde el paquete kbd integrado (en un vt separado): no se detectaron las claves de macro

• xev - teclas macro no detectadas

• contenido de / dev / input / by-path, así como la salida lsusb y evdev

• La salida de este script ahk sugiere que las teclas M no están generando códigos de escaneo estándar detectables por Windows

Cosas que necesito probar

• snoopy pro + ingeniería inversa (oh querido)

• Wireshark: el vagabundeo preliminar parece indicar que no se emiten códigos de escaneo cuando lo que parece pensar es que el teclado está monitoreado y las teclas presionadas. Podría indicar que las teclas adicionales son un dispositivo separado o deben inicializarse de alguna manera.

• Es necesario hacer una referencia cruzada con la salida lsusb de Linux, en tres escenarios: independiente, pasado a una máquina virtual de Windows sin los controladores instalados, y lo mismo con.

• LSUSB solo detecta un dispositivo en una instalación independiente de Linux

• Puede ser útil verificar si los ratones usan el mismo controlador Razer Synapse, ya que eso significa que alguna variación de razercfg podría funcionar (no detectado, solo parece funcionar para ratones)

Cosas que he resuelto:

• En un sistema Windows con el controlador, el teclado se ve como un teclado y un dispositivo señalador. El dispositivo señalador utiliza, además de los controladores de mouse estándar, un controlador para algo llamado Razer Synapse.

• Controlador de mouse visto en Linux debajo evdevy lsusbtambién

• Aparentemente, solo dispositivo con OS X, aunque todavía tengo que probar el lsusbequivalente en ese

• El teclado entra en modo de luz de fondo pulsante en OS X tras la inicialización con el controlador. Esto probablemente debería indicar que hay una secuencia de inicialización enviada al teclado en la activación.

• Son, de hecho, fancypants joojoo keys.

Extendiendo esta pregunta un poco:

Tengo acceso a un sistema de Windows, así que si necesito usar alguna herramienta para ayudar a responder la pregunta, está bien. También puedo probarlo en sistemas con y sin la utilidad de configuración. Sin embargo, el resultado final esperado es hacer que esas claves sean utilizables en Linux.

También me doy cuenta de que esta es una familia de hardware muy específica. Estaría dispuesto a probar cualquier cosa que tenga sentido en un sistema Linux si tengo instrucciones detalladas; esto debería abrir la pregunta a las personas que tienen habilidades en Linux, pero que no tienen acceso a este teclado.

El resultado final mínimo que requiero:

Necesito que estas teclas se detecten y se puedan usar de cualquier manera en cualquiera de las variantes gráficas de Ubuntu actuales y, naturalmente, tengo que trabajar con mi teclado. Cookies virtuales y accesorios locos si es algo bien empaquetado y utilizable por el usuario promedio.

Voy a requerir código compilado que funcione en mi sistema, o una fuente que pueda compilar (con instrucciones si es más compleja de lo que ./configure, make, make install) si el software adicional no en los repositorios de Ubuntu para la corriente LTS o la liberación de escritorio estándar en el momento de la respuesta. También requeriré suficiente información para replicar y usar con éxito las claves en mi propio sistema.

De hecho, M1-M5 son teclas normales: solo deben habilitarse específicamente antes de presionarlas para generar un código de escaneo. tux_mark_5 desarrolló un pequeño programa Haskell que envía el mensaje SET_REPORT correcto a los teclados Razer para habilitar estas teclas, y ex-loro portó el mismo código a Python.

En los sistemas Arch Linux, el puerto Python se ha empaquetado y está disponible en https://aur.archlinux.org/packages.php?ID=60518 .

En los sistemas Debian o Ubuntu, configurar el puerto Python del código es relativamente fácil. Necesita instalar PyUSB y libusb (como root):

    aptitude install python-usb

Luego tome el blackwidow_enable.pyarchivo de http://finch.am/projects/blackwidow/ y ejecútelo (también como root):

    chmod +x blackwidow_enable.py
    ./blackwidow_enable.py

Esto habilitará las teclas hasta que se desconecte el teclado o se reinicie la máquina. Para hacer esto permanente, llame al script desde cualquier estilo de script de inicio que prefiera. Para obtener instrucciones sobre cómo configurar esto en Debian, consulte la documentación de Debian .

Para usar el código Haskell de tux_mark_5, necesitarás instalar Haskell y compilar el código tú mismo. Estas instrucciones son para un sistema similar a Debian (incluido Ubuntu).

1. Instale GHC, libusb-1.0-0-dev y cabal (como root):

   aptitude install ghc libusb-1.0-0-dev cabal-install git pkg-config
   

2. Obtenga la lista de paquetes:

   cabal update
   

3. Instale enlaces USB para Haskell (sin necesidad de root):

   cabal install usb
   

4. Descargue la utilidad:

   git clone git://github.com/tuxmark5/EnableRazer.git
   

5. Construye la utilidad:

   cabal configure
   cabal build
   

6. Ejecute la utilidad (también como root):

   ./dist/build/EnableRazer/EnableRazer
   

Después de esto, puede copiar el binario EnableRazer en cualquier lugar que desee y ejecutarlo al inicio.

Inmediatamente después de la ejecución, el servidor X debería ver M1 como XF86Tools, M2 como XF86Launch5, M3 como XF86Launch6, M4 como XF86Launch7 y M5 como XF86Launch8. También se emiten eventos para FN.

Estas claves pueden vincularse dentro de xbindkeys o la configuración del sistema de KDE a acciones arbitrarias.

Dado que su teclado puede ser diferente, es posible que deba cambiar la ID del producto en Main.hs línea 64:

withDevice 0x1532 0x<HERE GOES YOUR KEYBOARD's PRODUCT ID> $ \dev -> do

Razer parece estar forzando su configurador Synapse 2 basado en la nube a todos los usuarios hoy en día, con la actualización de firmware que lo acompaña a la versión 2. *. Una vez que haya actualizado el firmware, no puede regresar (el teclado está completamente bloqueado si intenta actualizarlo con un firmware anterior).

Los 'bytes mágicos' del programa Haskell en la respuesta de tux_mark_5 no funcionarán con el último firmware. En cambio, el controlador envía estos bytes durante la secuencia de inicialización: '0200 0403'. Estos habilitan las teclas macro, pero el teclado ingresa a un modo peculiar en el que, en lugar del protocolo HID estándar, envía paquetes de 16 bytes (presumiblemente para aumentar la cantidad de teclas que se pueden presionar simultáneamente). El sistema HID de Linux no puede hacer frente a esto, y aunque la mayoría de las teclas funcionan como se esperaba, las teclas macro no se reconocen: el controlador HID no alimenta ningún dato a la capa de entrada cuando se presionan.

Para hacer que su teclado ingrese al modo heredado (en el cual las teclas de macro envían códigos de teclas XF86Launch *, y la tecla FN envía el código de tecla 202), envíe estos bytes: 0200 0402.

El paquete completo será:

00000000 00020004 02000000 00000000
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000
00000000 00000000 0400

Aquí hay un programa muy duro y sucio que escribí en Python 3 menos esotérico para realizar la tarea. Tenga en cuenta el código para generar los paquetes de control de Razer en blackwidow.bwcmd () y los comandos LED del logotipo de Razer como un bono :)

#!/usr/bin/python3

import usb
import sys

VENDOR_ID = 0x1532  # Razer
PRODUCT_ID = 0x010e  # BlackWidow / BlackWidow Ultimate

USB_REQUEST_TYPE = 0x21  # Host To Device | Class | Interface
USB_REQUEST = 0x09  # SET_REPORT

USB_VALUE = 0x0300
USB_INDEX = 0x2
USB_INTERFACE = 2

LOG = sys.stderr.write

class blackwidow(object):
  kernel_driver_detached = False

  def __init__(self):
    self.device = usb.core.find(idVendor=VENDOR_ID, idProduct=PRODUCT_ID)

    if self.device is None:
      raise ValueError("Device {}:{} not found\n".format(VENDOR_ID, PRODUCT_ID))
    else:
      LOG("Found device {}:{}\n".format(VENDOR_ID, PRODUCT_ID))

    if self.device.is_kernel_driver_active(USB_INTERFACE):
      LOG("Kernel driver active. Detaching it.\n")
      self.device.detach_kernel_driver(USB_INTERFACE)
      self.kernel_driver_detached = True

    LOG("Claiming interface\n")
    usb.util.claim_interface(self.device, USB_INTERFACE)

  def __del__(self):
    LOG("Releasing claimed interface\n")
    usb.util.release_interface(self.device, USB_INTERFACE)

    if self.kernel_driver_detached:
      LOG("Reattaching the kernel driver\n")
      self.device.attach_kernel_driver(USB_INTERFACE)

    LOG("Done.\n")

  def bwcmd(self, c):
    from functools import reduce
    c1 = bytes.fromhex(c)
    c2 = [ reduce(int.__xor__, c1) ]
    b = [0] * 90
    b[5: 5+len(c1)] = c1
    b[-2: -1] = c2
    return bytes(b)

  def send(self, c):
    def _send(msg):
      USB_BUFFER = self.bwcmd(msg)
      result = 0
      try:
        result = self.device.ctrl_transfer(USB_REQUEST_TYPE, USB_REQUEST, wValue=USB_VALUE, wIndex=USB_INDEX, data_or_wLength=USB_BUFFER)
      except:
        sys.stderr.write("Could not send data.\n")

      if result == len(USB_BUFFER):
        LOG("Data sent successfully.\n")

      return result

    if isinstance(c, list):
      #import time
      for i in c:
        print(' >> {}\n'.format(i))
        _send(i)
        #time.sleep(.05)
    elif isinstance(c, str):
        _send(c)

###############################################################################

def main():
    init_new  = '0200 0403'
    init_old  = '0200 0402'
    pulsate = '0303 0201 0402'
    bright  = '0303 0301 04ff'
    normal  = '0303 0301 04a8'
    dim     = '0303 0301 0454'
    off     = '0303 0301 0400'

    bw = blackwidow()
    bw.send(init_old)

if __name__ == '__main__':
    main()

Quizás esto podría arrojar algo de luz sobre el problema (de la página de manual de showkey):

En el modo crudo 2.6 kernels, o el modo scancode, no es muy crudo en absoluto. Los códigos de escaneo se traducen primero a códigos clave, y cuando se desean códigos de escaneo, los códigos de clave se vuelven a traducir. Hay varias transformaciones involucradas, y no hay ninguna garantía de que el resultado final corresponda a lo que envió el hardware del teclado. Entonces, si desea conocer los códigos de escaneo enviados por varias teclas, es mejor arrancar un kernel 2.4. Desde 2.6.9 también existe la opción de arranque atkbd.softraw = 0 que le dice al núcleo 2.6 que devuelva los códigos de escaneo reales.

Los códigos de exploración sin procesar solo están disponibles en los teclados AT y PS / 2, e incluso entonces están deshabilitados a menos que se use el parámetro del núcleo atkbd.softraw = 0. Cuando los códigos de escaneo sin formato no están disponibles, el núcleo utiliza una tabla integrada fija para producir códigos de escaneo a partir de códigos clave. Por lo tanto, setkeycodes (8) puede afectar la salida de showkey en el modo de volcado del código de escaneo.

Estoy a punto de ver si showkey volcará algo con las teclas de macro después de configurar esta opción de arranque.

EDITAR: después del reinicio, no hubo éxito, pero estaba buscando capturar la entrada sin formato de los propios dispositivos USB. Noté lo siguiente, curiosamente (tengo un Razer Diamondback y BlackWidow):

[root@kestrel by-id]# pwd
/dev/input/by-id
[root@kestrel by-id]# ls
usb-Razer_Razer_BlackWidow_Ultimate-event-kbd    usb-Razer_Razer_Diamondback_Optical_Mouse-event-mouse
usb-Razer_Razer_BlackWidow_Ultimate-event-mouse  usb-Razer_Razer_Diamondback_Optical_Mouse-mouse
usb-Razer_Razer_BlackWidow_Ultimate-mouse
[root@kestrel by-id]#

Sin embargo, el uso de dd para capturar la entrada sin formato funciona en ambos ratones diamondback, en el dispositivo event-kbd, pero no en los dispositivos de mouse BlackWidow.

Supongo que tal vez no generen ninguna salida hasta que los controladores que estén instalados los activen de alguna manera. Sin embargo, no sé mucho sobre Linux USB, por lo que ni siquiera sé si esto tiene sentido. ¿Quizás necesitan ser atados primero?

Bueno, los tres dispositivos de la viuda negra se mencionan /proc/bus/input/devices, sin embargo, no parecen estar enumerados en lsusbo /proc/bus/usb/devices. No estoy seguro de cómo acceder a estos dispositivos para intentar vincularlos o interactuar con ellos de alguna manera.

event4parece corresponder al teclado real, event6 con las teclas de macro, pero todavía no puedo capturar ninguna entrada de ellos. Espero que todos hayan ayudado.

   [root@kestrel input]# ls
devices  handlers
[root@kestrel input]# cat handlers
N: Number=0 Name=kbd
N: Number=1 Name=mousedev Minor=32
N: Number=2 Name=evdev Minor=64
N: Number=3 Name=rfkill
[root@kestrel input]# pwd
/proc/bus/input
[root@kestrel input]# cat devices
I: Bus=0019 Vendor=0000 Product=0001 Version=0000
N: Name="Power Button"
P: Phys=PNP0C0C/button/input0
S: Sysfs=/devices/LNXSYSTM:00/LNXSYBUS:00/PNP0C0C:00/input/input0
U: Uniq=
H: Handlers=kbd event0 
B: EV=3
B: KEY=10000000000000 0

I: Bus=0019 Vendor=0000 Product=0001 Version=0000
N: Name="Power Button"
P: Phys=LNXPWRBN/button/input0
S: Sysfs=/devices/LNXSYSTM:00/LNXPWRBN:00/input/input1
U: Uniq=
H: Handlers=kbd event1 
B: EV=3
B: KEY=10000000000000 0

I: Bus=0017 Vendor=0001 Product=0001 Version=0100
N: Name="Macintosh mouse button emulation"
P: Phys=
S: Sysfs=/devices/virtual/input/input2
U: Uniq=
H: Handlers=mouse0 event2 
B: EV=7
B: KEY=70000 0 0 0 0
B: REL=3

I: Bus=0003 Vendor=1532 Product=010d Version=0111
N: Name="Razer Razer BlackWidow Ultimate"
P: Phys=usb-0000:00:12.1-3/input0
S: Sysfs=/devices/pci0000:00/0000:00:12.1/usb4/4-3/4-3:1.0/input/input4
U: Uniq=
H: Handlers=kbd event4 
B: EV=120013
B: KEY=1000000000007 ff9f207ac14057ff febeffdfffefffff fffffffffffffffe
B: MSC=10
B: LED=7

I: Bus=0003 Vendor=1532 Product=010d Version=0111
N: Name="Razer Razer BlackWidow Ultimate"
P: Phys=usb-0000:00:12.1-3/input1
S: Sysfs=/devices/pci0000:00/0000:00:12.1/usb4/4-3/4-3:1.1/input/input5
U: Uniq=
H: Handlers=kbd event5 
B: EV=1f
B: KEY=837fff002c3027 bf00444400000000 1 c040a27c000 267bfad941dfed 9e000000000000 0
B: REL=40
B: ABS=100000000
B: MSC=10

I: Bus=0003 Vendor=1532 Product=010d Version=0111
N: Name="Razer Razer BlackWidow Ultimate"
P: Phys=usb-0000:00:12.1-3/input2
S: Sysfs=/devices/pci0000:00/0000:00:12.1/usb4/4-3/4-3:1.2/input/input6
U: Uniq=
H: Handlers=mouse2 event6 
B: EV=17
B: KEY=70000 0 0 0 0
B: REL=103
B: MSC=10

I: Bus=0003 Vendor=1532 Product=0002 Version=0110
N: Name="Razer Razer Diamondback Optical Mouse"
P: Phys=usb-0000:00:12.1-2/input0
S: Sysfs=/devices/pci0000:00/0000:00:12.1/usb4/4-2/4-2:1.0/input/input9
U: Uniq=
H: Handlers=mouse1 event3 
B: EV=17
B: KEY=7f0000 0 0 0 0
B: REL=103
B: MSC=10

[root@kestrel input]# 

Mi solución es para el teclado mecánico de juegos Razer BlackWidow 2013 (número de modelo: RZ03-0039) y se probó en openSUSE 12.3.

Utilicé Google Translate en este enlace .

Básicamente utiliza la versión modificada de la respuesta de @ Sergey para esta pregunta, pero con modificaciones simples:

1. Mi PRODUCT_ID = 0x011b

2. En mi openSUSE 12.3, python-usb no está disponible para Python 3, por lo que convertí este script para trabajar con Python 2 eliminando el bwcmdmétodo y definí el USB_BUFFER = ...como en el enlace de la respuesta de @ tux_mark_5 .

Por conveniencia, aquí está el contenido de mi /usr/local/sbin/init_blackwidow.py:

#!/usr/bin/python

"""This is a patched version of Sergey's code form
https://superuser.com/a/474595/8647

It worked for my Razer BlackWidow 2013 Mechanical Gaming Keyboard
(Model Number: RZ03-0039).

"""
import usb
import sys

VENDOR_ID = 0x1532       # Razer
PRODUCT_ID = 0x011b      # BlackWidow 2013 Mechanical Gaming Keyboard

USB_REQUEST_TYPE = 0x21  # Host To Device | Class | Interface
USB_REQUEST = 0x09       # SET_REPORT

USB_VALUE = 0x0300
USB_INDEX = 0x2
USB_INTERFACE = 2

USB_BUFFER = b"\x00\x00\x00\x00\x00\x02\x00\x04\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00"

LOG = sys.stderr.write


class blackwidow(object):
    kernel_driver_detached = False

    def __init__(self):
        self.device = usb.core.find(idVendor=VENDOR_ID, idProduct=PRODUCT_ID)

        if self.device is None:
            raise ValueError("Device {}:{} not found\n".format(VENDOR_ID, PRODUCT_ID))
        else:
            LOG("Found device {}:{}\n".format(VENDOR_ID, PRODUCT_ID))

        if self.device.is_kernel_driver_active(USB_INTERFACE):
            LOG("Kernel driver active. Detaching it.\n")
            self.device.detach_kernel_driver(USB_INTERFACE)
            self.kernel_driver_detached = True

        LOG("Claiming interface\n")
        usb.util.claim_interface(self.device, USB_INTERFACE)

    def __del__(self):
        LOG("Releasing claimed interface\n")
        usb.util.release_interface(self.device, USB_INTERFACE)

        if self.kernel_driver_detached:
            LOG("Reattaching the kernel driver\n")
            self.device.attach_kernel_driver(USB_INTERFACE)

        LOG("Done.\n")

    def send(self, c):
        def _send(msg):
            result = 0
            try:
                result = self.device.ctrl_transfer(USB_REQUEST_TYPE, USB_REQUEST, wValue=USB_VALUE, wIndex=USB_INDEX, data_or_wLength=USB_BUFFER)
            except:
                sys.stderr.write("Could not send data.\n")

            if result == len(USB_BUFFER):
                LOG("Data sent successfully.\n")

            return result

        if isinstance(c, list):
            for i in c:
                print(' >> {}\n'.format(i))
                _send(i)
        elif isinstance(c, str):
            _send(c)


def main():
    init_new = '0200 0403'
    init_old = '0200 0402'
    pulsate  = '0303 0201 0402'
    bright   = '0303 0301 04ff'
    normal   = '0303 0301 04a8'
    dim      = '0303 0301 0454'
    off      = '0303 0301 0400'

    bw = blackwidow()
    bw.send(init_old)


if __name__ == '__main__':
    main()

... y mi /etc/udev/rules.d/99-razer-balckwidow.ruleses:

SUBSYSTEM=="usb", ACTION=="add", ATTR{idVendor}=="1532", ATTR{idProduct}=="011b", RUN+="/usr/local/sbin/init_blackwidow.py"

Quizás este documento te ayude a:

El teclado y la consola de Linux COMO , Programas útiles

Ver Razer Key Mapper para Linux .

Esto funciona con todas las macros del dispositivo Razer, dada alguna modificación del código. Si aún no tiene una solución y su dispositivo no está en la lista, con gusto lo ayudaré a configurar su dispositivo y agregarlo a mi lista compatible.