Linux which key is pressed

Keyboard input

Prerequisite for modifying the key mapping is knowing how a key press results in a symbol:

1. The keyboard sends a scancode to the computer.
2. The Linux kernel maps the scancode to a keycode, see Map scancodes to keycodes.
3. The keyboard layout maps the keycode to a symbol or keysym, depending on what modifier keys are pressed.
   • For the Linux console, see Linux console/Keyboard configuration.
   • For Xorg and Wayland, see Xorg/Keyboard configuration.

Most of your keys should already have a keycode, or at least a scancode. Keys without a scancode are not recognized by the kernel; these can include additional keys from «gaming» keyboards, etc.

In Xorg, some keysyms (e.g. XF86AudioPlay , XF86AudioRaiseVolume etc.) can be mapped to actions (i.e. launching an external application). See Keyboard shortcuts#Xorg for details.

In Linux console, some keysyms (e.g. F1 to F246 ) can be mapped to certain actions (e.g. switch to other console or print some sequence of characters). See Console keyboard configuration#Creating a custom keymap for details.

Contents

Identifying scancodes

Using showkey

The traditional way to get a scancode is to use the showkey(1) utility. showkey waits for a key to be pressed, or exits if no keys are pressed within 10 seconds. For showkey to work you need to be in a virtual console, not in a graphical environment or logged in via a network connection. Run the following command:

and try to push keyboard keys; you should see scancodes being printed to the output.

Using evtest

For USB keyboards, it is apparently necessary to use evtest(1) from the evtest package instead of showkey [1]:

Use the «value» field of MSC_SCAN . This example shows that NumLock has scancode 70053 and keycode 69.

Using dmesg

You can get the scancode of a key by pressing the desired key and looking at the output of dmesg. For example, if you get:

then the scancode you need is 0xa0 .

Identifying keycodes

The Linux keycodes are defined in /usr/include/linux/input-event-codes.h (see the KEY_ variables).

Identifying keycodes in console

The keycodes for virtual console are reported by the showkey(1) utility. showkey waits for a key to be pressed and if none are, in a span of 10 seconds, it quits. To execute showkey, you need to be in a virtual console, not in a graphical environment. Run the following command:

and try to push keyboard keys; you should see keycodes being printed to the output.

Identifying keycodes in Xorg

This article or section needs expansion.

The keycodes used by Xorg are reported by a utility called xev(1) , which is provided by the xorg-xev package. Of course to execute xev, you need to be in a graphical environment, not in the console.

With the following command you can start xev and show only the relevant parts:

Here is an example output:

Xbindkeys is another wrapper to xev that reports keycodes.

If you press a key and nothing appears in the terminal, it means that either the key does not have a scancode, the scancode is not mapped to a keycode, or some other process is capturing the keypress. If you suspect that a process listening to X server is capturing the keypress, you can try running xev from a clean X session:

Источник

Linux console/Keyboard configuration

Keyboard mappings (keymaps), console fonts and console maps for the Linux console are provided by the kbd package (a dependency of systemd), which also provides many low-level tools for managing text console. In addition, systemd also provides the localectl tool, which can control both the system locale and keyboard layout settings for both the console and Xorg.

Contents

Viewing keyboard settings

Use localectl status to view the current keyboard configurations.

Keymaps

The keymap files are stored in the /usr/share/kbd/keymaps/ directory tree. Usually one keymap file corresponds to one keyboard layout (the include statement can be used to share common parts and a keymap file can contain multiple layouts with some key combination used for switching). For more details see keymaps(5) .

Listing keymaps

The naming conventions of console keymaps are somewhat arbitrary, but usually they are based on:

• Language codes: where the language code is the same as its country code (e.g. de for German, or fr for French).
• Country codes: where variations of the same language are used in different countries (e.g. uk for United Kingdom English, or us for United States English); a list of country codes can also be found in wikipedia:ISO 3166-1#Officially assigned code elements.
• Keyboard layouts: where the layout is not related to a particular country or language (e.g. dvorak for the Dvorak keyboard layout).

For a list of all the available keymaps, use the command:

To search for a keymap, use the following command, replacing search_term with the code for your language, country, or layout:

Alternatively, using find:

Loadkeys

It is possible to set a keymap just for current session. This is useful for testing different keymaps, solving problems etc.

The loadkeys tool is used for this purpose, it is used internally by systemd when loading the keymap configured in /etc/vconsole.conf . It can be used very simply for this purpose:

Persistent configuration

A persistent keymap can be set in /etc/vconsole.conf , which is read by systemd on start-up. The KEYMAP variable is used for specifying the keymap. If the variable is empty or not set, the us keymap is used as default value. See vconsole.conf(5) for all options. For example:

For convenience, localectl may be used to set console keymap. It will change the KEYMAP variable in /etc/vconsole.conf and also set the keymap for current session:

The —no-convert option can be used to prevent localectl from automatically changing the Xorg keymap to the nearest match. See localectl(1) for more information.

If required, the keymap from /etc/vconsole.conf can be loaded during early userspace by the keymap mkinitcpio hook.

Creating a custom keymap

When using the console, you can use hotkeys to print a specific character. Moreover we can also print a sequence of characters and some escape sequences. Thus, if we print the sequence of characters constituting a command and afterwards an escape character for a new line, that command will be executed.

One method of doing this is editing the keymap file. However, since it will be rewritten anytime the package it belongs to is updated, editing this file is discouraged. It is better to integrate the existing keymap with a personal keymap. The loadkeys utility can do this.

First, create a keymap file. This keymap file can be anywhere, but one method is to mimic the directory hierarchy in /usr/local :

As a side note, it is worth noting that such a personal keymap is useful also to redefine the behaviour of keys already treated by the default keymap: when loaded with loadkeys , the directives in the default keymap will be replaced when they conflict with the new directives and conserved otherwise. This way, only changes to the keymap must be specified in the personal keymap.

Adding directives

Two kinds of directives are required in this personal keymap. First of all, the keycode directives, which matches the format seen in the default keymaps. These directives associate a keycode with a keysym. Keysyms represent keyboard actions. The actions available include outputting character codes or character sequences, switching consoles or keymaps, booting the machine, and many other actions. The full currently active keymap can be obtained with

Most keysyms are intuitive. For example, to set key 112 to output an ‘e’, the directive will be:

To set key 112 to output a euro symbol, the directive will be:

Some keysym are not immediately connected to a keyboard actions. In particular, the keysyms prefixed by a capital F and one to three digits (F1-F246) constituting a number greater than 30 are always free. This is useful directing a hotkey to output a sequence of characters and other actions:

Then, F70 can be bound to output a specific string:

When key 112 is pressed, it will output the contents of F70. In order to execute a printed command in a terminal, a newline escape character must be appended to the end of the command string. For example, to enter a system into hibernation, the following keymap is added:

Other examples

• To make the Right Alt key same as Left Alt key (for Emacs), use the following line in your keymap. It will include the file /usr/share/kbd/keymaps/i386/include/linux-with-two-alt-keys.inc , check it for details.

• To swap CapsLock with Escape (for Vim), remap the respective keycodes:

• To make CapsLock another Control key, remap the respective keycode:

• To swap CapsLock with Left Control key, remap the respective keycodes:

Saving changes

In order to make use of the personal keymap, it must be loaded with loadkeys:

However this keymap is only active for the current session. In order to load the keymap at boot, specify the full path to the file in the KEYMAP variable in /etc/vconsole.conf. The file does not have to be gzipped as the official keymaps provided by kbd .

Adjusting typematic delay and rate

The typematic delay indicates the amount of time (typically in milliseconds) a key needs to be pressed and held in order for the repeating process to begin. After the repeating process has been triggered, the character will be repeated with a certain frequency (usually given in Hz) specified by the typematic rate. These values can be changed using the kbdrate command. Note that these settings are configured separately for the console and for Xorg.

For example to set a typematic delay to 200ms and a typematic rate to 30Hz, use the following command:

Issuing the command without specifying the delay and rate will reset the typematic values to their respective defaults; a delay of 250ms and a rate of 11Hz:

Systemd service

A systemd service can be used to set the keyboard rate. For example:

Источник

Linux which key is pressed

Take full control of your keyboard with this small Python library. Hook global events, register hotkeys, simulate key presses and much more.

• Global event hook on all keyboards (captures keys regardless of focus).
• Listen and send keyboard events.
• Works with Windows and Linux (requires sudo), with experimental OS X support (thanks @glitchassassin!).
• Pure Python, no C modules to be compiled.
• Zero dependencies. Trivial to install and deploy, just copy the files.
• Python 2 and 3.
• Complex hotkey support (e.g. ctrl+shift+m, ctrl+space ) with controllable timeout.
• Includes high level API (e.g. record and play, add_abbreviation).
• Maps keys as they actually are in your layout, with full internationalization support (e.g. Ctrl+ç ).
• Events automatically captured in separate thread, doesn’t block main program.
• Tested and documented.
• Doesn’t break accented dead keys (I’m looking at you, pyHook).
• Mouse support available via project mouse ( pip install mouse ).

or clone the repository (no installation required, source files are sufficient):

or download and extract the zip into your project folder.

Then check the API docs below to see what features are available.

Use as standalone module:

• Events generated under Windows don’t report device id ( event.device == None ). #21
• Media keys on Linux may appear nameless (scan-code only) or not at all. #20
• Key suppression/blocking only available on Windows. #22
• To avoid depending on X, the Linux parts reads raw device files ( /dev/input/input* ) but this requires root.
• Other applications, such as some games, may register hooks that swallow all key events. In this case keyboard will be unable to report events.
• This program makes no attempt to hide itself, so don’t use it for keyloggers or online gaming bots. Be responsible.
• SSH connections forward only the text typed, not keyboard events. Therefore if you connect to a server or Raspberry PI that is running keyboard via SSH, the server will not detect your key events.

Common patterns and mistakes

Preventing the program from closing

Waiting for a key press one time

Repeatedly waiting for a key press

Invoking code when an event happens

‘Press any key to continue’

Table of Contents

• keyboard.KEY_DOWN
• keyboard.KEY_UP
• keyboard.KeyboardEvent
• keyboard.all_modifiers
• keyboard.sided_modifiers
• keyboard.version
• keyboard.is_modifier
• keyboard.key_to_scan_codes
• keyboard.parse_hotkey
• keyboard.send(aliases: press_and_release )
• keyboard.press
• keyboard.release
• keyboard.is_pressed
• keyboard.call_later
• keyboard.hook
• keyboard.on_press
• keyboard.on_release
• keyboard.hook_key
• keyboard.on_press_key
• keyboard.on_release_key
• keyboard.unhook(aliases: unblock_key , unhook_key , unremap_key )
• keyboard.unhook_all
• keyboard.block_key
• keyboard.remap_key
• keyboard.parse_hotkey_combinations
• keyboard.add_hotkey(aliases: register_hotkey )
• keyboard.remove_hotkey(aliases: clear_hotkey , unregister_hotkey , unremap_hotkey )
• keyboard.unhook_all_hotkeys(aliases: clear_all_hotkeys , remove_all_hotkeys , unregister_all_hotkeys )
• keyboard.remap_hotkey
• keyboard.stash_state
• keyboard.restore_state
• keyboard.restore_modifiers
• keyboard.write
• keyboard.wait
• keyboard.get_hotkey_name
• keyboard.read_event
• keyboard.read_key
• keyboard.read_hotkey
• keyboard.get_typed_strings
• keyboard.start_recording
• keyboard.stop_recording
• keyboard.record
• keyboard.play(aliases: replay )
• keyboard.add_word_listener(aliases: register_word_listener )
• keyboard.remove_word_listener(aliases: remove_abbreviation )
• keyboard.add_abbreviation(aliases: register_abbreviation )
• keyboard.normalize_name

keyboard.KEY_DOWN

keyboard.KEY_UP

class keyboard.KeyboardEvent

KeyboardEvent.device

KeyboardEvent.event_type

KeyboardEvent.is_keypad

KeyboardEvent.modifiers

KeyboardEvent.name

KeyboardEvent.scan_code

KeyboardEvent.time

KeyboardEvent.to_json(self, ensure_ascii=False)

keyboard.all_modifiers

keyboard.sided_modifiers

keyboard.version

keyboard.is_modifier(key)

Returns True if key is a scan code or name of a modifier key.

keyboard.key_to_scan_codes(key, error_if_missing=True)

Returns a list of scan codes associated with this key (name or scan code).

keyboard.parse_hotkey(hotkey)

Parses a user-provided hotkey into nested tuples representing the parsed structure, with the bottom values being lists of scan codes. Also accepts raw scan codes, which are then wrapped in the required number of nestings.

keyboard.send(hotkey, do_press=True, do_release=True)

Sends OS events that perform the given hotkey hotkey.

• hotkey can be either a scan code (e.g. 57 for space), single key (e.g. ‘space’) or multi-key, multi-step hotkey (e.g. ‘alt+F4, enter’).
• do_press if true then press events are sent. Defaults to True.
• do_release if true then release events are sent. Defaults to True.

Note: keys are released in the opposite order they were pressed.

keyboard.press(hotkey)

Presses and holds down a hotkey (see send ).

keyboard.release(hotkey)

Releases a hotkey (see send ).

keyboard.is_pressed(hotkey)

Returns True if the key is pressed.

keyboard.call_later(fn, args=(), delay=0.001)

Calls the provided function in a new thread after waiting some time. Useful for giving the system some time to process an event, without blocking the current execution flow.

keyboard.hook(callback, suppress=False, on_remove= )

Installs a global listener on all available keyboards, invoking callback each time a key is pressed or released.

The event passed to the callback is of type keyboard.KeyboardEvent , with the following attributes:

• name : an Unicode representation of the character (e.g. «&») or description (e.g. «space»). The name is always lower-case.
• scan_code : number representing the physical key, e.g. 55.
• time : timestamp of the time the event occurred, with as much precision as given by the OS.

Returns the given callback for easier development.

keyboard.on_press(callback, suppress=False)

Invokes callback for every KEY_DOWN event. For details see hook .

keyboard.on_release(callback, suppress=False)

Invokes callback for every KEY_UP event. For details see hook .

keyboard.hook_key(key, callback, suppress=False)

Hooks key up and key down events for a single key. Returns the event handler created. To remove a hooked key use unhook_key(key) or unhook_key(handler) .

Note: this function shares state with hotkeys, so clear_all_hotkeys affects it as well.

keyboard.on_press_key(key, callback, suppress=False)

Invokes callback for KEY_DOWN event related to the given key. For details see hook .

keyboard.on_release_key(key, callback, suppress=False)

Invokes callback for KEY_UP event related to the given key. For details see hook .

keyboard.unhook(remove)

Removes a previously added hook, either by callback or by the return value of hook .

keyboard.unhook_all()

Removes all keyboard hooks in use, including hotkeys, abbreviations, word listeners, record ers and wait s.

keyboard.block_key(key)

Suppresses all key events of the given key, regardless of modifiers.

keyboard.remap_key(src, dst)

Whenever the key src is pressed or released, regardless of modifiers, press or release the hotkey dst instead.

keyboard.parse_hotkey_combinations(hotkey)

Parses a user-provided hotkey. Differently from parse_hotkey , instead of each step being a list of the different scan codes for each key, each step is a list of all possible combinations of those scan codes.

keyboard.add_hotkey(hotkey, callback, args=(), suppress=False, timeout=1, trigger_on_release=False)

Invokes a callback every time a hotkey is pressed. The hotkey must be in the format ctrl+shift+a, s . This would trigger when the user holds ctrl, shift and «a» at once, releases, and then presses «s». To represent literal commas, pluses, and spaces, use their names (‘comma’, ‘plus’, ‘space’).

• args is an optional list of arguments to passed to the callback during each invocation.
• suppress defines if successful triggers should block the keys from being sent to other programs.
• timeout is the amount of seconds allowed to pass between key presses.
• trigger_on_release if true, the callback is invoked on key release instead of key press.

The event handler function is returned. To remove a hotkey call remove_hotkey(hotkey) or remove_hotkey(handler) . before the hotkey state is reset.

Note: hotkeys are activated when the last key is pressed, not released. Note: the callback is executed in a separate thread, asynchronously. For an example of how to use a callback synchronously, see wait .

keyboard.remove_hotkey(hotkey_or_callback)

Removes a previously hooked hotkey. Must be called with the value returned by add_hotkey .

keyboard.unhook_all_hotkeys()

Removes all keyboard hotkeys in use, including abbreviations, word listeners, record ers and wait s.

keyboard.remap_hotkey(src, dst, suppress=True, trigger_on_release=False)

Whenever the hotkey src is pressed, suppress it and send dst instead.

keyboard.stash_state()

Builds a list of all currently pressed scan codes, releases them and returns the list. Pairs well with restore_state and restore_modifiers .

keyboard.restore_state(scan_codes)

Given a list of scan_codes ensures these keys, and only these keys, are pressed. Pairs well with stash_state , alternative to restore_modifiers .

keyboard.restore_modifiers(scan_codes)

Like restore_state , but only restores modifier keys.

keyboard.write(text, delay=0, restore_state_after=True, exact=None)

Sends artificial keyboard events to the OS, simulating the typing of a given text. Characters not available on the keyboard are typed as explicit unicode characters using OS-specific functionality, such as alt+codepoint.

To ensure text integrity, all currently pressed keys are released before the text is typed, and modifiers are restored afterwards.

• delay is the number of seconds to wait between keypresses, defaults to no delay.
• restore_state_after can be used to restore the state of pressed keys after the text is typed, i.e. presses the keys that were released at the beginning. Defaults to True.
• exact forces typing all characters as explicit unicode (e.g. alt+codepoint or special events). If None, uses platform-specific suggested value.

keyboard.wait(hotkey=None, suppress=False, trigger_on_release=False)

Blocks the program execution until the given hotkey is pressed or, if given no parameters, blocks forever.

keyboard.get_hotkey_name(names=None)

Returns a string representation of hotkey from the given key names, or the currently pressed keys if not given. This function:

• normalizes names;
• removes «left» and «right» prefixes;
• replaces the «+» key name with «plus» to avoid ambiguity;
• puts modifier keys first, in a standardized order;
• sort remaining keys;
• finally, joins everything with «+».

keyboard.read_event(suppress=False)

Blocks until a keyboard event happens, then returns that event.

keyboard.read_key(suppress=False)

Blocks until a keyboard event happens, then returns that event’s name or, if missing, its scan code.

keyboard.read_hotkey(suppress=True)

Similar to read_key() , but blocks until the user presses and releases a hotkey (or single key), then returns a string representing the hotkey pressed.

keyboard.get_typed_strings(events, allow_backspace=True)

Given a sequence of events, tries to deduce what strings were typed. Strings are separated when a non-textual key is pressed (such as tab or enter). Characters are converted to uppercase according to shift and capslock status. If allow_backspace is True, backspaces remove the last character typed.

This function is a generator, so you can pass an infinite stream of events and convert them to strings in real time.

Note this functions is merely an heuristic. Windows for example keeps per- process keyboard state such as keyboard layout, and this information is not available for our hooks.

keyboard.start_recording(recorded_events_queue=None)

Starts recording all keyboard events into a global variable, or the given queue if any. Returns the queue of events and the hooked function.

keyboard.stop_recording()

Stops the global recording of events and returns a list of the events captured.

keyboard.record(until=’escape’, suppress=False, trigger_on_release=False)

Records all keyboard events from all keyboards until the user presses the given hotkey. Then returns the list of events recorded, of type keyboard.KeyboardEvent . Pairs well with play(events) .

Note: this is a blocking function. Note: for more details on the keyboard hook and events see hook .

keyboard.play(events, speed_factor=1.0)

Note: the current keyboard state is cleared at the beginning and restored at the end of the function.

keyboard.add_word_listener(word, callback, triggers=[‘space’], match_suffix=False, timeout=2)

Invokes a callback every time a sequence of characters is typed (e.g. ‘pet’) and followed by a trigger key (e.g. space). Modifiers (e.g. alt, ctrl, shift) are ignored.

• word the typed text to be matched. E.g. ‘pet’.
• callback is an argument-less function to be invoked each time the word is typed.
• triggers is the list of keys that will cause a match to be checked. If the user presses some key that is not a character (len>1) and not in triggers, the characters so far will be discarded. By default the trigger is only space .
• match_suffix defines if endings of words should also be checked instead of only whole words. E.g. if true, typing ‘carpet’+space will trigger the listener for ‘pet’. Defaults to false, only whole words are checked.
• timeout is the maximum number of seconds between typed characters before the current word is discarded. Defaults to 2 seconds.

Returns the event handler created. To remove a word listener use remove_word_listener(word) or remove_word_listener(handler) .

Note: all actions are performed on key down. Key up events are ignored. Note: word matches are case sensitive.

keyboard.remove_word_listener(word_or_handler)

Removes a previously registered word listener. Accepts either the word used during registration (exact string) or the event handler returned by the add_word_listener or add_abbreviation functions.

keyboard.add_abbreviation(source_text, replacement_text, match_suffix=False, timeout=2)

Registers a hotkey that replaces one typed text with another. For example

Replaces every «tm» followed by a space with a ™ symbol (and no space). The replacement is done by sending backspace events.

• match_suffix defines if endings of words should also be checked instead of only whole words. E.g. if true, typing ‘carpet’+space will trigger the listener for ‘pet’. Defaults to false, only whole words are checked.
• timeout is the maximum number of seconds between typed characters before the current word is discarded. Defaults to 2 seconds.

keyboard.normalize_name(name)

Given a key name (e.g. «LEFT CONTROL»), clean up the string and convert to the canonical representation (e.g. «left ctrl») if one is known.

About

Hook and simulate global keyboard events on Windows and Linux.

Источник