Far funzionare i tasti macro da una Razer BlackWidow su Linux

Ho preso un Razer BlackWidow Ultimate che ha tasti aggiuntivi pensati per le macro che sono impostati usando uno strumento installato su Windows . Presumo che questi non siano alcuni tasti joojoo fantasiosi e dovrebbero emettere scancodes come qualsiasi altro tasto.

In primo luogo, esiste un modo standard per controllare questi scancodes in Linux? In secondo luogo, come posso impostare queste chiavi per fare cose nella riga di comando e nelle configurazioni Linux basate su X? La mia attuale installazione Linux è Xubuntu 10.10, ma passerò a Kubuntu una volta sistemate alcune cose. Idealmente, la risposta dovrebbe essere generica e a livello di sistema.

Cose che ho provato finora:

• showkeys dal pacchetto kbd integrato (in una vt separata) - chiavi macro non rilevate

• xev - tasti macro non rilevati

• contenuto di / dev / input / by-path e output di lsusb ed evdev

• L' output di questo script ahk suggerisce che i tasti M non emettono scancodes standard rilevabili da Windows

Cose che devo provare

• snoopy pro + reverse engineering (oh caro)

• Wireshark - il giro preliminare in giro sembra indicare che non sono stati emessi scancodes quando ciò che penso sia la tastiera viene monitorata e i tasti premuti. Potrebbe indicare che tasti aggiuntivi sono un dispositivo separato o devono essere inizializzati in qualche modo.

• È necessario fare un riferimento incrociato a quello con l'output di lsusb da Linux, in tre scenari: autonomo, passato a una macchina virtuale Windows senza i driver installati e lo stesso con.

• LSUSB rileva solo un dispositivo su un'installazione Linux autonoma

• Potrebbe essere utile verificare se i mouse utilizzano lo stesso driver Razer Synapse, poiché ciò significa che alcune variazioni di razercfg potrebbero funzionare (non rilevate, sembra funzionare solo per i mouse)

Cose che ho elaborato:

• In un sistema Windows con driver, la tastiera è vista come una tastiera e un dispositivo di puntamento. Il dispositivo di puntamento utilizza, oltre ai driver del mouse standard per la torbiera, un driver per qualcosa chiamato Razer Synapse.

• Il driver del mouse visto in Linux sotto evdeve lsusbpure

• Apparentemente un singolo dispositivo con OS X, anche se devo ancora provare l' lsusbequivalente su questo

• La tastiera entra in modalità di retroilluminazione pulsante in OS X dopo l'inizializzazione con il driver. Ciò dovrebbe probabilmente indicare che c'è una sequenza di inizializzazione inviata alla tastiera all'attivazione.

• Sono, infatti, chiavi joojoo fantasiose.

Estendendo un po 'questa domanda:

Ho accesso a un sistema Windows, quindi se ho bisogno di usare strumenti su questo per aiutare a rispondere alla domanda, va bene. Posso anche provarlo su sistemi con e senza l'utility di configurazione. Il risultato finale atteso è comunque rendere utilizzabili quelle chiavi su Linux.

Capisco anche che questa è una famiglia di hardware molto specifica. Sarei disposto a testare qualsiasi cosa abbia senso su un sistema Linux se avessi istruzioni dettagliate - questo dovrebbe aprire la domanda a persone che hanno abilità Linux, ma non hanno accesso a questa tastiera.

Il risultato finale minimo che richiedo:

Ho bisogno che questi tasti vengano rilevati e utilizzabili in qualsiasi modo su una qualsiasi delle attuali varianti grafiche di Ubuntu, e naturalmente devo lavorare con la mia tastiera. Cookie virtuale e oggetti di scena pazzi se è qualcosa di ben confezionato e utilizzabile dall'utente medio.

Io chiederò codice compilato che funziona sul mio sistema, o di una fonte che posso compilare (con le istruzioni se è più complessa di quanto ./configure, make, make install) se il software aggiuntivo non sui repository di Ubuntu per i LTS o rilascio desktop standard al momento della la risposta. Richiederò anche informazioni sufficienti per replicare e utilizzare con successo le chiavi sul mio sistema.

M1-M5 sono in realtà tasti regolari - devono solo essere specificamente abilitati prima di premerli genererà uno scancode. tux_mark_5 ha sviluppato un piccolo programma Haskell che invia il messaggio SET_REPORT corretto alle tastiere Razer per abilitare questi tasti ed ex-parrot ha portato lo stesso codice su Python.

Sui sistemi Arch Linux la porta Python è stata impacchettata ed è disponibile da https://aur.archlinux.org/packages.php?ID=60518 .

Sui sistemi Debian o Ubuntu configurare la porta Python del codice è relativamente semplice. Devi installare PyUSB e libusb (come root):

    aptitude install python-usb

Quindi prendi il blackwidow_enable.pyfile da http://finch.am/projects/blackwidow/ ed eseguilo (anche come root):

    chmod +x blackwidow_enable.py
    ./blackwidow_enable.py

Ciò abiliterà i tasti fino allo scollegamento della tastiera o al riavvio della macchina. Per rendere permanente questo chiamare lo script da qualsiasi stile di script di avvio che preferisci di più. Per istruzioni su come configurarlo in Debian, dai un'occhiata alla documentazione di Debian .

Per utilizzare il codice Haskell di tux_mark_5 dovrai installare Haskell e compilare il codice da solo. Queste istruzioni sono per un sistema simile a Debian (incluso Ubuntu).

1. Installa GHC, libusb-1.0-0-dev e cabal (come root):

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

2. Recupera l'elenco dei pacchetti:

   cabal update
   

3. Installa i collegamenti USB per Haskell (non è necessario il root):

   cabal install usb
   

4. Scarica l'utilità:

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

5. Costruisci l'utilità:

   cabal configure
   cabal build
   

6. Esegui l'utilità (anche come root):

   ./dist/build/EnableRazer/EnableRazer
   

Dopodiché puoi copiare il binario EnableRazer dove vuoi ed eseguirlo all'avvio.

Immediatamente dopo l'esecuzione, il server X dovrebbe vedere M1 come XF86Tools, M2 come XF86Launch5, M3 come XF86Launch6, M4 come XF86Launch7 e M5 come XF86Launch8. Vengono emessi anche eventi per FN.

Queste chiavi possono essere associate a xbindkeys o alle impostazioni di sistema di KDE ad azioni arbitrarie.

Poiché la tastiera potrebbe essere diversa, potrebbe essere necessario modificare l'ID prodotto nella riga 64 di Main.hs:

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

Razer sembra forzare il configuratore Synapse 2 basato su cloud su tutti gli utenti al giorno d'oggi, con l'aggiornamento del firmware di accompagnamento alla versione 2. *. Dopo aver aggiornato il firmware, non è possibile tornare indietro (la tastiera è completamente in muratura se si tenta di eseguire il flashing con un firmware precedente).

I "byte magici" del programma Haskell nella risposta di tux_mark_5 non funzioneranno con l'ultimo firmware. Al contrario, il driver invia questi byte durante la sequenza di inizializzazione: "0200 0403". Questi abilitano i tasti macro, ma la tastiera entra in una modalità particolare in cui invece del protocollo HID standard invia pacchetti a 16 byte (presumibilmente per aumentare il numero di tasti che possono essere premuti contemporaneamente). Il sistema HID Linux non può farcela, e mentre la maggior parte dei tasti funziona come previsto, i tasti macro rimangono non riconosciuti: il driver HID non fornisce dati al livello di input quando vengono premuti.

Per rendere la tastiera attiva la modalità legacy (in cui i tasti macro inviano i codici chiave XF86Launch * e il tasto FN invia il codice chiave 202), inviare questi byte: 0200 0402.

Il pacchetto completo sarà:

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

Ecco un programma molto approssimativo e sporco che ho scritto in Python 3 meno esoterico per eseguire l'operazione. Nota il codice per generare i pacchetti di controllo Razer in blackwidow.bwcmd () e i comandi LED del logo Razer come 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()

Forse questo potrebbe far luce sul problema (dalla manpage showkey):

Nella modalità raw kernel 2.6, o modalità scancode, non è affatto molto grezzo. I codici di scansione vengono prima tradotti in codici chiave e, quando si desiderano gli scancodes, i codici chiave vengono tradotti nuovamente. Sono coinvolte varie trasformazioni e non vi è alcuna garanzia che il risultato finale corrisponda a ciò che l'hardware della tastiera ha inviato. Quindi, se si desidera conoscere i codici di scansione inviati da varie chiavi, è meglio avviare un kernel 2.4. Da 2.6.9 esiste anche l'opzione di avvio atkbd.softraw = 0 che dice al kernel 2.6 di restituire i codici di scansione effettivi.

I codici di scansione non elaborati sono disponibili solo sulle tastiere AT e PS / 2 e anche in questo caso sono disabilitati a meno che non venga utilizzato il parametro kernel atkbd.softraw = 0. Quando i codici di scansione grezzi non sono disponibili, il kernel utilizza una tabella integrata fissa per produrre codici di scansione da codici chiave. Pertanto, setkeycodes (8) può influenzare l'output di showkey in modalità dump del codice di scansione.

Sto per vedere se showkey scaricherà qualcosa con i tasti macro dopo aver impostato questa opzione di avvio.

EDIT: dopo il riavvio, nessun successo, ma stavo cercando di catturare l'input non elaborato dai dispositivi USB stessi. Ho notato quanto segue, interessante (ho un Razer Diamondback e 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]#

Tuttavia, l'utilizzo di dd per acquisire input non elaborati funziona su entrambi i mouse diamondback, sul dispositivo event-kbd, ma non sui dispositivi mouse BlackWidow.

Suppongo che forse non generano alcun output fino a quando in qualche modo non sono stati attivati ​​dai driver installati. Tuttavia, non so molto su Linux USB, quindi non so nemmeno se abbia senso. Forse devono prima essere legati?

Bene, tutti e tre i dispositivi della vedova nera sono annotati in /proc/bus/input/devices, tuttavia non sembrano essere elencati in lsusbo /proc/bus/usb/devices. Non sono sicuro di come accedere a questi dispositivi per tentare di vincolarli o interfacciarli in alcun modo.

event4sembra corrispondere alla tastiera effettiva, event6 con i tasti macro, ma non riesco ancora a catturare alcun input da essi. Spero che tutto abbia aiutato.

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

La mia soluzione è per la tastiera da gioco meccanica Razer BlackWidow 2013 (numero di modello: RZ03-0039) ed è stata testata su openSUSE 12.3.

Ho usato Google Translate su questo link .

Fondamentalmente utilizza la versione modificata della risposta di @ Sergey per questa domanda, ma con semplici modifiche:

1. Mio PRODUCT_ID = 0x011b

2. Sul mio openSUSE 12.3, python-usb non è disponibile per Python 3, quindi ho convertito questo script in modo che funzioni con Python 2 rimuovendo il bwcmdmetodo e ho definito USB_BUFFER = ...come nel link dalla risposta di @ tux_mark_5 .

Per comodità ecco il contenuto del mio /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()

... e il mio /etc/udev/rules.d/99-razer-balckwidow.rulesè:

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

Forse questo documento ti aiuterà:

Tastiera Linux e console HOWTO , Programmi utili

Vedi Razer Key Mapper per Linux .

Funziona con tutte le macro del dispositivo Razer, date alcune modifiche al codice. Se non hai ancora una soluzione e il tuo dispositivo non è elencato, sarei felice di aiutarti a configurare il tuo dispositivo e aggiungerlo alla mia lista supportata.