Makrotasten von einer Razer BlackWidow zum Laufen unter Linux bekommen

M1-M5 sind in der Tat normale Tasten - sie müssen nur speziell aktiviert werden, bevor sie gedrückt werden, um einen Scancode zu generieren. tux_mark_5 hat ein kleines Haskell-Programm entwickelt, das die korrekte SET_REPORT-Nachricht an Razer-Tastaturen sendet, um diese Tasten zu aktivieren, und ex-parrot hat denselben Code nach Python portiert.

Auf Arch Linux-Systemen wurde der Python-Port gepackt und ist unter https://aur.archlinux.org/packages.php?ID=60518.

verfügbar

Auf Debian- oder Ubuntu-Systemen ist das Einrichten der Python-Portierung des Codes relativ einfach. Sie müssen PyUSB und libusb (als root) installieren:

    aptitude install python-usb

Dann nimm den blackwidow_enable.py Datei von http://finch.am/projects/blackwidow/ und führe sie aus (auch als root):

    chmod +x blackwidow_enable.py
    ./blackwidow_enable.py

Dadurch werden die Tasten aktiviert, bis die Tastatur abgezogen oder der Computer neu gestartet wird. Um dies dauerhaft zu machen, rufen Sie das Skript von dem Startskripttyp auf, den Sie am meisten bevorzugen. Für Anweisungen, wie man dies in Debian einrichtet, werfen Sie einen Blick in die Debian-Dokumentation.

Um den Haskell-Code von tux_mark_5 zu verwenden, müssen Sie Haskell installieren und den Code selbst kompilieren. Diese Anweisungen gelten für ein Debian-ähnliches System (einschließlich Ubuntu).

1. Installieren Sie GHC, libusb-1.0-0-dev und Cabal (als root):

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

2. Holen Sie sich die Liste der Pakete:

   cabal update
   

3. Installieren Sie USB-Anbindungen für Haskell (kein Root erforderlich):

   cabal install usb
   

4. Laden Sie das Dienstprogramm herunter:

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

5. Erstellen Sie das Dienstprogramm:

   cabal configure
   cabal build
   

6. Führen Sie das Dienstprogramm aus (auch als root):

   ./dist/build/EnableRazer/EnableRazer
   

Danach können Sie die EnableRazer-Binärdatei überall kopieren und beim Start ausführen.

Unmittelbar nach der Ausführung sollte der X-Server M1 als XF86Tools, M2 als XF86Launch5, M3 als XF86Launch6, M4 als XF86Launch7 und M5 als XF86Launch8 sehen. Ereignisse für FN werden ebenfalls ausgegeben.

Diese Tasten können innerhalb von xbindkeys oder den Systemeinstellungen von KDE an beliebige Aktionen gebunden werden.

Da Ihre Tastatur möglicherweise anders ist, müssen Sie möglicherweise die Produkt-ID in Zeile 64 von Main.hs ändern:

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

Razer scheint seinen Cloud-basierten Konfigurator Synapse 2 heutzutage allen Benutzern aufzuzwingen, mit begleitendem Firmware-Upgrade auf Version 2.*. Sobald Sie die Firmware aktualisiert haben, können Sie nicht mehr zurückgehen (die Tastatur wird vollständig gemauert, wenn Sie versuchen, sie mit älterer Firmware zu flashen).

Die „Magic Bytes“ aus dem Haskell-Programm in der Antwort von tux_mark_5 funktionieren nicht mit der neuesten Firmware. Stattdessen sendet der Treiber diese Bytes während der Initialisierungssequenz:„0200 0403“. Diese aktivieren die Makrotasten, aber die Tastatur wechselt in einen besonderen Modus, in dem sie anstelle des Standard-HID-Protokolls 16-Byte-Pakete sendet (vermutlich, um die Anzahl der Tasten zu erhöhen, die gleichzeitig gedrückt werden können). Das Linux-HID-System kann damit nicht ganz fertig werden, und während die meisten Tasten wie erwartet funktionieren, bleiben die Makrotasten unerkannt:Der HID-Treiber gibt keine Daten an die Eingabeschicht weiter, wenn sie gedrückt werden.

Um Ihre Tastatur in den Legacy-Modus zu versetzen (in dem die Makrotasten XF86Launch*-Tastencodes senden und die FN-Taste den Tastencode 202 sendet), senden Sie diese Bytes:0200 0402.

Das vollständige Paket wird sein:

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

Hier ist ein sehr grobes und schmutziges Programm, das ich in weniger esoterischem Python 3 geschrieben habe, um die Aufgabe auszuführen. Beachten Sie den Code zum Generieren der Razer-Steuerungspakete in blackwidow.bwcmd() und die Razer-Logo-LED-Befehle als 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()

Vielleicht könnte dies etwas Licht auf das Problem werfen (von der Showkey-Manpage):

In Kernel 2.6 ist der Raw-Modus oder Scancode-Modus überhaupt nicht sehr roh. Scancodes werden zuerst in Tastencodes übersetzt, und wenn Scancodes gewünscht werden, werden die Tastencodes zurückübersetzt. Es sind verschiedene Transformationen erforderlich, und es gibt keinerlei Garantie dafür, dass das Endergebnis dem entspricht, was die Tastaturhardware gesendet hat. Wenn Sie also wissen möchten, welche Scan-Codes von verschiedenen Schlüsseln gesendet werden, ist es besser, einen 2.4-Kernel zu booten. Seit 2.6.9 gibt es auch die Boot-Option atkbd.softraw=0, die den 2.6er Kernel anweist, die eigentlichen Scan-Codes zurückzugeben.

Die Raw-Scan-Codes sind nur auf AT- und PS/2-Tastaturen verfügbar, und selbst dann sind sie deaktiviert, es sei denn, der Kernel-Parameter atkbd.softraw=0 wird verwendet. Wenn die rohen Scancodes nicht verfügbar sind, verwendet der Kernel eine fest eingebaute Tabelle, um Scancodes aus Keycodes zu erzeugen. Daher kann setkeycodes(8) die Ausgabe von showkey im Scan-Code-Dump-Modus beeinflussen.

Ich werde sehen, ob showkey irgendetwas mit den Makrotasten ausgibt, nachdem diese Boot-Option festgelegt wurde.

BEARBEITEN:Nach dem Neustart kein Erfolg, aber ich habe versucht, Rohdaten von den USB-Geräten selbst zu erfassen. Interessanterweise habe ich Folgendes festgestellt (ich habe sowohl eine Razer Diamondback als auch eine BlackWidow):

[[email protected] by-id]# pwd
/dev/input/by-id
[[email protected] 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
[[email protected] by-id]#

Die Verwendung von dd zum Erfassen von Roheingaben funktioniert jedoch auf beiden Diamondback-Mäusen, auf dem event-kbd-Gerät, aber nicht auf den BlackWidow-Mausgeräten.

Ich vermute, dass sie möglicherweise keine Ausgabe erzeugen, bis sie irgendwie von den installierten Treibern aktiviert werden. Ich weiß jedoch nicht viel über Linux USB, also weiß ich nicht einmal, ob das Sinn macht. Vielleicht müssen sie erst gebunden werden?

Nun, alle drei Black-Widow-Geräte sind in /proc/bus/input/devices aufgeführt , sie scheinen jedoch nicht in lsusb aufgezählt zu werden oder /proc/bus/usb/devices . Ich bin mir nicht sicher, wie ich auf diese Geräte zugreifen soll, um zu versuchen, sie zu binden oder in irgendeiner Weise mit ihnen zu kommunizieren.

event4 scheint der tatsächlichen Tastatur event6 mit den Makrotasten zu entsprechen, aber ich kann immer noch keine Eingaben von ihnen erfassen. Hoffe, dass alles geholfen hat.

   [[email protected] input]# ls
devices  handlers
[[email protected] 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
[[email protected] input]# pwd
/proc/bus/input
[[email protected] 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

[[email protected] input]#