Obtenir les clés de macro d'un Razer BlackWidow pour fonctionner sur Linux

J'ai choisi une Razer BlackWidow Ultimate dotée de clés supplémentaires destinées aux macros définies à l'aide d'un outil installé sur Windows . Je suppose que ce ne sont pas des clés joojoo de fantaisie et devraient émettre des scancodes comme n'importe quelle autre clé.

Premièrement, existe-t-il un moyen standard de vérifier ces scancodes sous Linux? Deuxièmement, comment définir ces clés pour effectuer des opérations dans les configurations en ligne de commande et sous Linux? Mon installation Linux actuelle est Xubuntu 10.10, mais je vais passer à Kubuntu une fois que plusieurs choses auront été corrigées. Idéalement, la réponse devrait être générique et s’appliquer à l’ensemble du système.

Ce que j'ai essayé jusqu'à présent:

• showkeys à partir du paquetage kbd intégré (dans un vt séparé) - clés de macro non détectées

• xev - touches macro non détectées

• contenu de / dev / input / by-path ainsi que des sorties lsusb et evdev

• Cette la sortie du script AHK indique les touches M ne sont pas restituent scancodes standards détectables par les fenêtres

Choses que j'ai besoin d'essayer

• snoopy pro + ingénierie inverse (oh mon Dieu)

• Wireshark - les premiers tests semblent indiquer qu’aucun scancode n’est émis lorsque je pense que le clavier est surveillé et que les touches sont enfoncées. Peut indiquer que les clés supplémentaires constituent un périphérique distinct ou doivent être initialisées d'une manière ou d'une autre.

• Il faut croiser cette référence avec la sortie lsusb de Linux dans trois scénarios: autonome, transmise à une machine virtuelle Windows sans les pilotes installés, et la même chose avec.

• LSUSB détecte uniquement un périphérique sur une installation autonome de Linux

• Il peut être utile de vérifier si les souris utilisent le même pilote Razer Synapse, car cela signifie qu'une variante de razercfg pourrait fonctionner (non détectée, elle ne semble fonctionner que pour les souris).

Les choses que j'ai travaillées:

• Dans un système Windows avec pilote, le clavier est considéré comme un clavier et un périphérique de pointage. Le périphérique de pointage utilise, en plus de vos pilotes de souris standard, un pilote pour quelque chose appelé Razer Synapse.

• Pilote de souris vu dans Linux sous evdevet lsusbainsi

• Un seul appareil sous OS X apparemment, même si je n'ai pas encore essayé d' lsusbéquivalent sur ce

• Le clavier passe en mode rétroéclairage pulsé sous OS X lors de l'initialisation avec le pilote. Cela devrait probablement indiquer qu'une séquence d'initialisation a été envoyée au clavier lors de l'activation.

• Ce sont en fait des clés de fantaisie joojoo.

Prolonger un peu cette question:

J'ai accès à un système Windows, donc si je dois utiliser des outils pour aider à répondre à la question, c'est très bien. Je peux aussi l'essayer sur des systèmes avec et sans l'utilitaire de configuration. Le résultat final attendu reste toutefois de rendre ces clés utilisables sous Linux.

Je réalise également qu'il s'agit d'une famille de matériel très spécifique. Je serais prêt à tester tout ce qui a du sens sur un système Linux si j'ai des instructions détaillées - cela devrait ouvrir la question aux personnes ayant des compétences en Linux, mais n'ayant pas accès à ce clavier.

Le résultat final minimum dont j'ai besoin:

J'ai besoin que ces clés soient détectées et utilisables de toutes les manières sur toutes les variantes graphiques actuelles d'Ubuntu; elles doivent naturellement fonctionner avec mon clavier. Cookie virtuel et accessoires délirants s’il s’agit de quelque chose de joliment emballé et utilisable par l’utilisateur moyen.

Je réclamerai le code compilé qui fonctionnera sur mon système, ou une source que je peux compiler (avec des instructions si elle est plus complexe que ./configure, make, make install) si un logiciel supplémentaire non sur les dépôts Ubuntu pour la version actuelle de bureau LTS ou standard au moment de la réponse. J'aurai également besoin d'informations suffisantes pour répliquer et utiliser avec succès les clés de mon propre système.

Les touches M1-M5 sont en fait des clés ordinaires - elles doivent simplement être spécifiquement activées avant de les presser pour générer un scancode. tux_mark_5 a développé un petit programme Haskell qui envoie le message SET_REPORT correct aux claviers Razer pour activer ces clés, et ex-parrot a porté le même code vers Python.

Sur les systèmes Arch Linux, le port Python est fourni et disponible à l’ adresse https://aur.archlinux.org/packages.php?ID=60518 .

Sur les systèmes Debian ou Ubuntu, configurer le port Python du code est relativement facile. Vous devez installer PyUSB et libusb (en tant que root):

    aptitude install python-usb

Ensuite, récupérez le blackwidow_enable.pyfichier sur http://finch.am/projects/blackwidow/ et exécutez-le (également en tant que root):

    chmod +x blackwidow_enable.py
    ./blackwidow_enable.py

Cela permettra d'activer les touches jusqu'à ce que le clavier soit débranché ou que la machine soit redémarrée. Pour rendre cette tâche permanente, appelez le script à partir du style de script de démarrage que vous préférez. Pour des instructions sur la manière de configurer cela dans Debian, jetez un œil à la documentation Debian .

Pour utiliser le code Haskell de tux_mark_5, vous devez installer Haskell et le compiler vous-même. Ces instructions concernent un système de type Debian (y compris Ubuntu).

1. Installez GHC, libusb-1.0-0-dev et cabal (en tant que root):

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

2. Récupérer la liste des paquets:

   cabal update
   

3. Installez les liaisons USB pour Haskell (pas besoin de root):

   cabal install usb
   

4. Téléchargez l'utilitaire:

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

5. Construisez l'utilitaire:

   cabal configure
   cabal build
   

6. Exécutez l'utilitaire (également en tant que root):

   ./dist/build/EnableRazer/EnableRazer
   

Ensuite, vous pouvez copier le fichier binaire EnableRazer où vous le souhaitez et l'exécuter au démarrage.

Immédiatement après son exécution, le serveur X doit afficher M1 comme XF86Tools, M2 comme XF86Launch5, M3 comme XF86Launch6, M4 comme XF86Launch7 et M5 comme XF86Launch8. Les événements pour FN sont également émis.

Ces clés peuvent être liées dans xbindkeys ou les paramètres système de KDE à des actions arbitraires.

Étant donné que votre clavier peut être différent, vous devrez peut-être modifier l'ID du produit dans la ligne 64 de Main.hs:

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

Razer semble forcer son configurateur basé sur le cloud Synapse 2 sur tous les utilisateurs, avec la mise à niveau du micrologiciel qui l'accompagne vers la version 2. *. Une fois le micrologiciel mis à niveau, vous ne pouvez plus revenir en arrière (le clavier est complètement branché si vous essayez de le flasher avec un micrologiciel plus ancien).

Les «octets magiques» du programme Haskell dans la réponse de tux_mark_5 ne fonctionneront pas avec le dernier firmware. Au lieu de cela, le pilote envoie ces octets lors de la séquence d'initialisation: '0200 0403'. Celles-ci activent les touches de macro, mais le clavier entre dans un mode particulier dans lequel, au lieu du protocole standard HID, il envoie des paquets de 16 octets (probablement pour augmenter le nombre de touches pouvant être enfoncées simultanément). Le système Linux HID ne peut pas tout à fait gérer cela, et alors que la plupart des clés fonctionnent comme prévu, les clés de macro restent non reconnues: le pilote HID ne fournit aucune donnée à la couche d’entrée lorsqu’elles sont enfoncées.

Pour que votre clavier passe en mode hérité (dans lequel les touches de macro envoient les codes XF86Launch * et la touche FN envoie le code 202), envoyez ces octets: 0200 0402.

Le paquet complet sera:

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

Voici un programme très dur et sale que j'ai écrit en Python 3, moins ésotérique, pour effectuer cette tâche. Notez le code pour générer les paquets de contrôle Razer dans blackwidow.bwcmd () et les commandes du logo du logo Razer en bonus :)

#!/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()

Peut-être que ceci pourrait éclairer un peu la question (de la page de manuel de showkey):

Dans les noyaux 2.6, le mode brut, ou mode scancode, n’est pas très brut du tout. Les codes de numérisation sont d'abord traduits en codes de clé, et lorsque des codes à balayage sont souhaités, les codes de clé sont reconvertis. Diverses transformations sont impliquées et rien ne garantit que le résultat final correspond à ce que le matériel du clavier a envoyé. Donc, si vous voulez connaître les codes d'analyse envoyés par différentes clés, il est préférable de démarrer un noyau 2.4. Depuis la version 2.6.9, l’option de démarrage atkbd.softraw = 0 indique également au noyau 2.6 de renvoyer les codes d’analyse réels.

Les codes de balayage bruts ne sont disponibles que sur les claviers AT et PS / 2 et, même dans ce cas, ils sont désactivés, sauf si le paramètre de noyau atkbd.softraw = 0 est utilisé. Lorsque les codes d'analyse bruts ne sont pas disponibles, le noyau utilise un tableau intégré fixe pour produire des codes d'analyse à partir de codes clés. Ainsi, setkeycodes (8) peut affecter la sortie de showkey en mode de vidage du code de balayage.

Je suis sur le point de voir si showkey dumpera quoi que ce soit avec les touches de macro après la définition de cette option de démarrage.

EDIT: Après le redémarrage, aucun succès, mais je cherchais à capturer une entrée brute à partir des périphériques USB eux-mêmes. J'ai noté ce qui suit, intéressant (j'ai un Razer Diamondback ainsi que 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]#

Toutefois, l'utilisation de dd pour capturer une entrée brute fonctionne sur les deux souris Diamondback, sur le périphérique event-kbd, mais pas sur les souris BlackWidow.

J'imagine qu'ils ne génèrent peut-être aucune sortie tant qu'ils ne sont pas activés par les pilotes installés. Cependant, je ne connais pas grand chose à propos de Linux USB, donc je ne sais même pas si cela a du sens. Peut-être ont-ils besoin d'être liés en premier?

Eh bien, les trois dispositifs de veuve noire sont notés dans /proc/bus/input/devices, mais ils ne semblent pas être énumérés dans lsusbou /proc/bus/usb/devices. Je ne sais pas comment accéder à ces périphériques pour tenter de les lier ou de s'y connecter de quelque manière que ce soit.

event4semble correspondre au clavier actuel, event6 avec les touches de macro, mais je ne peux toujours pas capturer leur entrée. J'espère que tout a aidé.

   [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]# 

Ma solution concerne le clavier de jeu mécanique Razer BlackWidow 2013 (numéro de modèle: RZ03-0039) et a été testée sur openSUSE 12.3.

J'ai utilisé Google Translate sur ce lien .

Fondamentalement, il utilise la version modifiée de la réponse de @ Sergey pour cette question, mais avec de simples modifications:

1. ma PRODUCT_ID = 0x011b

2. Sur mon openSUSE 12.3, python-usb n'étant pas disponible pour Python 3, j'ai donc converti ce script pour qu'il fonctionne avec Python 2 en supprimant la bwcmdméthode et en définissant la valeur USB_BUFFER = ...as dans le lien de la réponse de @ tux_mark_5 .

Pour plus de commodité, voici le contenu de mon /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()

... et mon /etc/udev/rules.d/99-razer-balckwidow.rulesest:

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

Peut-être que ce document vous aidera:

HOWTO Clavier et console Linux , Programmes utiles

Voir Razer Key Mapper pour Linux .

Cela fonctionne avec toutes les macros des périphériques Razer, moyennant certaines modifications du code. Si vous n'avez toujours pas de solution et que votre appareil ne figure pas dans la liste, je serais ravi de vous aider à configurer votre appareil et à l'ajouter à ma liste prise en charge.