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

49

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:

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.

Compagnon Geek
la source
s'il vous plaît mettre à jour avec toutes les solutions, j'aimerais atteindre le même!
Jonathan Day
Je n’ai vraiment pas eu le temps d’y travailler ces derniers temps, mais je mettrai à jour cette question avec tout ce que j’ai fait, jusqu’à ce que je reçoive une réponse.
Compagnon Geek
Peut-être modifier pour mentionner le représentant 500 dans la grande police? Sinon, cette proclamation n'a pas beaucoup de sens (compte tenu de la prime de 50 représentants enregistrée auprès du système)
Daniel Beck
Est-ce que cela fonctionne toujours pour vous? (Je parle du dernier firmware mentionné ci-dessous par Sergey)
Adonis K. Kakoulidis
Je ne l'ai pas testée, j'ai bien peur de vouloir essayer la solution de Sergey pour voir si cela fonctionne, mais j'ai utilisé Windows principalement pour les devoirs. Si c'est le cas, je posterai un commentaire en ce sens
Journeyman Geek

Réponses:

44

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
tux_mark_5
la source
Cela fonctionne, bon départ. Vous aurez 500 représentants dans un jour ou deux, lorsque le système me le permettra. J'ai pris la liberté d'ajouter pkg-config, qui était nécessaire pour installer une condition préalable du package haskell usb dans la liste des conditions préalables. Le logiciel fonctionne sans aucune modification sur mon Blackwidow Ultimate standard, avec un ID de produit de 1532: 010d selon lsusb. Les clés sont détectées sur evtest et semblent être utilisables, donc cela a parfaitement répondu aux exigences de la question.
Journeyman Geek
de plus, kde ne dispose pas d'une option de liaison clé semble-t-il, xbindkeys semble fonctionner
Journeyman Geek
avec ID 10e cela fonctionne avec mon blackwidow standard (non-ultime). Je recommande d’ajouter une règle udev afin qu’elle démarre automatiquement, sans problème, par exemple créer un fichier avec 99-enable-razer-keyboard.rules int /etc/udev/rules.d dans lequel SUBSYSTEM=="usb", ACTION=="add", ATTR{idVendor}=="1532", ATTR{idProduct}=="010e", RUN+="/root/EnableRazer"vous devrez peut-être modifier le fichier. chemin et id à nouveau)
flolo
Apparemment, l'utilitaire que j'ai écrit fonctionne également avec Razer Anansi. Voici le blog de quelqu'un qui a réussi cela: norgelinux.blogspot.com/2012/02/razer-anasi-on-arch-linux.html
tux_mark_5
1
J'ai le Razer BlackWidow 2013 (pas le nec plus ultra), quand j'exécute le script blackwidow_enable.py (avec et sans racine), je reçois le message "Blackwidow introuvable". Pourriez-vous s'il vous plaît m'aider à déboguer ceci? Je suis sur UbuntuGnome 13.04. Il semble que le Product_ID soit différent et, après avoir modifié l'ID du produit, le message d'erreur suivant Could not select configuration endpoint.
s'affiche
22

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()
Sergey
la source
mon clavier a été mis à jour et je ne l'ai pas encore essayé. Je vais tenter le coup lorsque je disposerai à nouveau d'un système Linux approprié. Malheureusement, je ne peux pas donner une autre prime pour cela - en partie à cause du fonctionnement du système de primes. Je vais probablement passer la bonne réponse à la vôtre si c'est le cas.
Journeyman Geek
apparemment, le module usb manque sur mon système, donc cela ne fonctionne pas: /
Journeyman Geek
Le module usb est probablement dans le paquet pyusb (ou python-usb ou quelque chose de similaire, en fonction de la distribution).
Sergey
2
Merci beaucoup Sergey, cela fonctionne même avec le plus récent Razer BlackWidow 2013 avec PRODUCT_ID = 0x011b. Je n'ai pas encore essayé de définir de macro, mais je vois les événements provenant de / dev / input / by-id / usb-Razer_Razer_BlackWidow_2013-event-kbd et également dans xev :).
binary_runner
Merci, c'est génial. Je l'utilise depuis quelques années maintenant sans aucun problème (j'ai enfin la réputation de commenter :)). Un commentaire sur pyusb: Ubuntu n’expédiant toujours pas pyusb pour python 3, j’ai dû l’installer manuellement à partir de la source en utilisantsudo python3 setup.py install
luator
8

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]# 
srmaddox
la source
Je suppose que le système doit communiquer avec le clavier pour les initialiser - avec OS X, mon clavier est lancé dans le mode de lumière pulsée. Il faut probablement une certaine initialisation pour que les touches de macro du clavier fonctionnent
Journeyman Geek
Ce que je me demande, c'est comment envoyer ces informations à la souris et aux périphériques de souris d'événements. event-mouse semble être responsable, puisqu'il est lié à un gestionnaire d'événement clavier. Je veux dire, théoriquement, tout ce que nous aurions à faire est d’initialiser l’appareil et d’installer la carte appropriée scancode-> keycode avec setkeycode et ittl enregistrer les événements sous forme de frappes au clavier normales.
srmaddox
Peut-être que je peux simplement ouvrir Eclipse et écrire un programme pour autoriser les entrées / sorties brutes vers / depuis le périphérique. Les essais et les erreurs peuvent alors prévaloir.
Sremaddox
jespersaur.com/drupal/book/export/html/21 Cela devrait présenter un intérêt tout au long du processus. C'est bien au-delà de mes compétences.
Journeyman Geek
7

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"
Chen Levy
la source
Où avez-vous trouvé une copie de pyusb qui a usb.util?
KayEss
@KayEss, j'utilise python-usb-1.0.0-21.1.noarch.rpm. IIRC fait partie des référentiels de stadard de 0penSUSE 12.3. Selon rpm -qi, la source est sur sourceforge.net/projects/pyusb et la source du paquet est sur obs: //build.opensuse.org/devel: languages: python
Chen Levy
Je suis sur Ubuntu, et il n'y a pas de version packagée pour python3 à ce sujet. J'avais alors un peu de difficulté à mettre tous les fichiers sudo, python3, pip et virtualenv en ligne, mais tout est trié et je vois des codes pour les clés de macro.
KayEss
1
@KayEss, pour Ubuntu 14.04, j'ai utilisé les instructions de: github.com/walac/pyusb . En particulier: sudo apt-get install python libusb-1.0-0sudoetpip install pyusb --pre
Chen Levy le
2

Peut-être que ce document vous aidera:

HOWTO Clavier et console Linux , Programmes utiles

ascobole
la source
c'est un début, et mérite une upvote. Il est intéressant de noter que les touches de macro n'apparaissent pas du tout dans les avants
Journeyman Geek
peut-être que cette clé macro n'émet que scancode en combinaison avec une autre clé. Comme un scancode pour la macro-1, etc.?
Ascobol
1
Ils semblent fonctionner indépendamment une fois configurés dans Windows. Je devrais peut-être envisager une approche de niveau inférieur. À mon avis, il existe une prise en charge des souris fabriquées par la même société avec razercfg qui utilise des scancodes non standard. il h. Si c'était facile, je suppose que je l'aurais trouvé;)
Journeyman Geek
Ce document n'a pas été mis à jour depuis 2002. Est-il toujours d'actualité?
Peter Mortensen
1

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.

Camille Guay
la source
Comment est-ce mieux que la réponse acceptée?
Toto
1
Plus simple je suppose. Pré-fait. Il ne reste plus qu'à remplir les fichiers de configuration.
Camille Guay