Full key customization on input device

Abstract

The invention discloses full key customization on an input device. A method includes: receiving a first control signal indicating that a first key on a keyboard is being pressed, the first key functionally assigned as a (logical) modifier; sending a first enable command indicating that the modifier is valid; receiving a second control signal indicating that second keys on the keyboard are being simultaneously pressed, the second keys functionally assigned as alphanumeric characters that are not modifiers; accessing a key remapping database stored on the keyboard, the key remapping database including the key triggers and the remapped key targets; in response to determining that a combination of the first key and the second key is included as a key trigger in the key remapping data sending a first interrupt command indicating that the modifier is invalid; and transmitting a second enable command corresponding to a key target of the remapping database associated with a combination of the pressed first and second keys.

Description

Technical Field

[0001] The present disclosure relates to input devices. Background Art

[0002] Input devices such as keyboards or key-based computer peripherals remain popular and effective user interfaces between people and computers. Over the years, keyboards have been developed and improved in terms of quality, function, ergonomics and lifespan. Modern keyboards typically include numeric keypads, function keys, media keys and many other key functions of any number of different configurations. Although many configurations and options are available to consumers, keyboards are typically locked into specific key arrangements and corresponding functions. Therefore, users may resort to purchasing multiple keyboard devices to better adapt to specific applications, which may be expensive and wasteful. Better solutions are needed. Summary of the invention

[0003] In some embodiments, a method includes: receiving, by one or more processors of a keyboard, a first control signal indicating that a first key on the keyboard is being pressed, the first key being functionally assigned as a modifier; sending, by the one or more processors, a first enable command indicating that the modifier is valid to a host computing device communicatively coupled to the keyboard; receiving, by the one or more processors, a second control signal indicating that a second key on the keyboard is being simultaneously pressed, the second key being functionally assigned as an alphanumeric character that is not a modifier; accessing, by the one or more processors, a key remapping database stored on the keyboard, the key remapping database including key triggers and remapped key targets, each key trigger corresponding to a specific combination of one or more keys of the keyboard, and each corresponding key target corresponding to a function assignment that is different than a default function assignment for the combination of the one or more keys. In some embodiments, in response to determining that the combination of the first key and the second key is included as a key trigger in the key remapping database, the method includes: while the first key and the second key are pressed, sending, by the one or more processors, a first interrupt command indicating that the modifier is invalid to the host computing device; and while the first key and the second key are pressed, sending, by the one or more processors, to the host computing device a second enable command corresponding to a key target of the remapping database associated with the pressed combination of the first key and the second key. In some embodiments, in response to determining that the combination of the first key and the second key is not included as a key trigger in the key remapping database, the method includes: while the first key and the second key are pressed, sending, by the one or more processors, to the host computing device a third enable command corresponding to an alphanumeric character that is not a modifier of the second key.

[0004] In some cases, the method includes: receiving, by one or more processors, an indication that a second key on the keyboard is released; and sending, by one or more processors, a second interrupt command to the host computing device indicating that the target key is terminated. The method may also include: receiving, by one or more processors, a third control signal indicating that a third key on the keyboard is being pressed while the first key is still being pressed; accessing, by one or more processors, a key remapping database; and in response to determining that the combination of the first key and the third key is included in the remapping database as a key trigger, the method may include: sending, by one or more processors, to the host computing device a third enable command corresponding to a key target associated with the combination of the pressed first key and the third key of the remapping database while the first key and the third key are pressed. In certain embodiments, the method may include: in response to determining that the combination of the first key and the third key is not included in the remapping database as a key trigger: sending, by one or more processors, to the host computing device a fourth enable command indicating that the modifier is switched from invalid to valid while the first key and the third key are pressed; and sending, by one or more processors, to the host computing device a fifth enable command corresponding to the default function assignment of the third key while the first key and the third key are pressed. In some embodiments, the method may include: receiving, by one or more processors, an indication that a third key on the keyboard is released; sending, by one or more processors, a third interrupt command to a host computing device indicating that a default function assignment of the third key is terminated; receiving, by one or more processors, an indication that a first key on the keyboard is released; and sending, by one or more processors, to the host computing device, a fourth interrupt command indicating that a modifier is released. In some cases, a key target may include a combination of multiple function assignments. The key remapping database may be stored as a list-based or bit-field-based database on a memory stored on the keyboard. The keyboard may communicate with the host computing device via human interface device (HID) type commands.

[0005] In certain embodiments, a keyboard includes: one or more processors; one or more non-transitory computer-readable storage media containing instructions, the instructions being configured to cause the one or more processors to perform operations, the operations including: receiving, by the one or more processors of the keyboard, a first control signal indicating that a first key on the keyboard is being pressed, the first key being functionally assigned as a modifier; sending, by the one or more processors, a first enable command indicating that the modifier is valid to a host computing device communicatively coupled to the keyboard; receiving, by the one or more processors, a second control signal indicating that a second key on the keyboard is being simultaneously pressed, the second key being functionally assigned as an alphanumeric character that is not a modifier; and accessing, by the one or more processors, a key remapping database stored on the keyboard, the key remapping database including key triggers and remapped key targets, each key trigger corresponding to a specific combination of one or more keys of the keyboard, and each corresponding key target corresponding to a function assignment that is different from a default function assignment for the combination of the one or more keys. In some aspects, in response to determining that a combination of a first key and a second key is included as a key trigger in a key remapping database, the method includes: while the first key and the second key are pressed, sending, by one or more processors, a first interrupt command indicating that a modifier is invalid to a host computing device; and while the first key and the second key are pressed, sending, by one or more processors, to the host computing device, a second enable command corresponding to a key target of the remapping database associated with the pressed combination of the first key and the second key. In some cases, the instructions are further configured to cause the one or more processors to perform operations, the operations including: in response to determining that the combination of the first key and the second key is not included as a key trigger in the key remapping database: while the first key and the second key are pressed, sending, by one or more processors, to the host computing device, a third enable command corresponding to an alphanumeric character that is not a modifier of the second key.

[0006] In another embodiment, the instructions are further configured to cause one or more processors to perform operations, the operations including: receiving an indication that a second key on the keyboard is released by the one or more processors; and sending a second interrupt command to the host computing device indicating that the target key is terminated by the one or more processors. In some aspects, the instructions are further configured to cause one or more processors to perform operations, the operations including: receiving a third control signal indicating that a third key on the keyboard is being pressed while the first key is still being pressed by the one or more processors; accessing a key remapping database by the one or more processors; in response to determining that the combination of the first key and the third key is included in the remapping database as a key trigger: while the first key and the third key are being pressed, sending a third enable command corresponding to the key target associated with the combination of the pressed first key and the third key of the remapping database to the host computing device by the one or more processors. In some implementations, the instructions are further configured to cause one or more processors to perform operations, the operations comprising: in response to determining that the combination of the first key and the third key is not included as a key trigger in the remapping database: while the first key and the third key are pressed, sending, by the one or more processors, a fourth enable command indicating that the modifier is switched from invalid to valid to the host computing device; and while the first key and the third key are pressed, sending, by the one or more processors, a fifth enable command corresponding to the default function assignment of the third key to the host computing device. In some cases, the instructions are further configured to cause one or more processors to perform operations, the operations comprising: receiving, by the one or more processors, an indication that the third key on the keyboard is released; sending, by the one or more processors, a third interrupt command indicating that the default function assignment of the third key is terminated to the host computing device; receiving, by the one or more processors, an indication that the first key on the keyboard is released; sending, by the one or more processors, a fourth interrupt command indicating that the modifier is released to the host computing device.

[0007] In some embodiments, a non-transitory computer program product is tangibly embodied in a machine-readable non-transitory storage medium, the machine-readable non-transitory storage medium including instructions configured to cause one or more processors to perform operations, the operations including: receiving, by one or more processors of a keyboard, a first control signal indicating that a first key on the keyboard is being pressed, the first key being functionally assigned as a modifier; sending, by the one or more processors, a first enable command to a host computing device communicatively coupled to the keyboard indicating that the modifier is valid; receiving, by the one or more processors, a second control signal indicating that a second key on the keyboard is being simultaneously pressed, the second key being functionally assigned as an alphanumeric character that is not a modifier; accessing, by the one or more processors, a control signal stored in a memory cell; A key remapping database on a keyboard, the key remapping database including key triggers and remapped key targets, each key trigger corresponding to a specific combination of one or more keys of the keyboard, and each corresponding key target corresponding to a function assignment different from a default function assignment for the combination of the one or more keys; in response to determining that a combination of a first key and a second key is included as a key trigger in the key remapping database: while the first key and the second key are pressed, sending, by one or more processors, a first interrupt command indicating that a modifier is invalid to a host computing device; and while the first key and the second key are pressed, sending, by one or more processors, to the host computing device a second enable command corresponding to a key target of the remapping database associated with the combination of the pressed first key and the second key.

[0008] In some aspects, the instructions further cause the one or more processors to perform operations, the operations comprising: in response to determining that the combination of the first key and the second key is not included as a key trigger in the key remapping database: while the first key and the second key are pressed, sending, by the one or more processors, a third enable command corresponding to the non-modifier alphanumeric character of the second key to the host computing device. In some cases, the instructions further cause the one or more processors to perform operations, the operations comprising: receiving, by the one or more processors, an indication that the second key on the keyboard is released; and sending, by the one or more processors, to the host computing device a second interrupt command indicating that the target key is terminated. In some implementations, the instructions are further configured to cause one or more processors to perform operations, the operations including: receiving, by the one or more processors, a third control signal indicating that a third key on the keyboard is being pressed while the first key is still being pressed; accessing, by the one or more processors, a key remapping database; in response to determining that the combination of the first key and the third key is included as a key trigger in the remapping database: sending, by the one or more processors, a third enable command corresponding to a key target associated with the pressed combination of the first key and the third key of the remapping database to the host computing device while the first key and the third key are pressed. In some implementations, the instructions are further configured to cause one or more processors to perform operations, the operations including: in response to determining that the combination of the first key and the third key is not included as a key trigger in the remapping database: sending, by the one or more processors, a fourth enable command indicating that the modifier is switched from invalid to valid to the host computing device while the first key and the third key are pressed; and sending, by the one or more processors, a fifth enable command corresponding to the default function assignment of the third key to the host computing device while the first key and the third key are pressed.

[0009] The terms and expressions that have been employed are used as terms of description rather than limitation, and it is not intended that the use of such terms and expressions exclude any equivalents of the features shown and described, or portions thereof. However, it is recognized that various modifications are possible within the scope of the claimed system and method. Therefore, it should be understood that although the present system and method have been specifically disclosed by way of examples and optional features, those skilled in the art should recognize modifications and variations of the concepts disclosed herein, and such modifications and variations are considered to be within the scope of the system and method defined by the appended claims.

[0010] This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used in isolation to determine the scope of the claimed subject matter. The subject matter should be understood by reference to appropriate portions of the entire specification of the disclosure, any or all drawings, and each claim.

[0011] The foregoing and other features and examples will be described in more detail in the following description, claims and accompanying drawings. BRIEF DESCRIPTION OF THE DRAWINGS

[0012] The features of the above-mentioned various embodiments of the present invention as well as other features and advantages of certain embodiments will become more apparent from the following detailed description taken in conjunction with the accompanying drawings, in which:

[0013] Figure 1 An example of a computer system is shown that may include any of a variety of host computing devices and computer peripherals, including computer peripherals that may be configured to perform aspects of the various inventive concepts described herein;

[0014] Figure 2 shows a simplified block diagram of a system configured for operating an input device according to certain embodiments;

[0015] Figure 3 shows a simplified block diagram of a system for operating a host computing device according to certain embodiments;

[0016] Figure 4 shows an example of a base layer, a FN layer, and a GShift layer in an input device utilizing a FKC system according to some embodiments;

[0017] Figure 5 and Figure 6 shows the logical results of certain key press combinations on a keyboard according to certain embodiments;

[0018] Figure 7 is a simplified flow chart illustrating aspects of a method for FKC triggered matching according to certain embodiments;

[0019] Figure 8 shows a lookup table for multiple layers in a FKC-enabled input device according to some embodiments;

[0020] Fig. 9 is a simplified flow chart illustrating aspects of a method for remapping keys on an FKC-enabled input device according to certain embodiments;

[0021] Fig.10 is a simplified flow chart illustrating aspects of a method for remapping keys on an FKC-enabled input device according to certain embodiments;

[0022] Fig.11 is a simplified flow chart illustrating aspects of a method for remapping keys on an FKC-enabled input device according to certain embodiments; and

[0023] Fig.12 is a simplified flow chart illustrating aspects of a method for remapping keys on an FKC-enabled input device according to certain implementations.

[0024] Throughout the drawings, it should be noted that like reference numbers are generally used to depict the same or similar elements, features, and structures. DETAILED DESCRIPTION

[0025] According to certain implementations, aspects of the present disclosure relate generally to electronic devices and, more particularly, to programmable input devices.

[0026] In the following description, various examples of programmable input devices are described. For illustrative purposes, specific configurations and details are set forth to provide a thorough understanding of the embodiments. However, it will be apparent to those skilled in the art that certain embodiments may be practiced or implemented without every detail disclosed. In addition, well-known features may be omitted or simplified to prevent any confusion with the novel features described herein.

[0027] The following high-level overview is intended to provide a basic understanding of some of the novel innovations depicted in the accompanying drawings and presented in the corresponding description provided below. Various aspects of the present invention relate to input devices with onboard systems (e.g., firmware) to achieve fully customizable keys, buttons and shortcut keys, which are made feasible by assigning new target behaviors to specific trigger keys. Other aspects include novel methods for controlling the logic of sending remapped data to a communicatively coupled host computing device via local processing (e.g., firmware), which results in improved latency, accuracy, reliability and consistency, thereby contributing to an improved user experience (UX). Software-based (SW) FKC systems such as those found in some conventional devices generally exhibit poor latency and consistency. For example, in SW-based FKC systems, the total time from user key presses to corresponding device reports delivered to the host computing device operating system (OS) can be within tens of milliseconds to hundreds of milliseconds. This latency may be overlooked for some applications such as audio volume adjustment, but may be catastrophic in some game scenarios (e.g., FPS, driving simulators, etc.), and is therefore intolerable for modern consumers. Another problem with SW-based FKC systems is the behavior when the system is started or awakened from sleep mode. Before gaining access to the OS, the user usually has to enter a password. At this point, because the OS and the corresponding software have not yet established FKC remapping, the input device will usually be in its default operating mode. Therefore, if a cryptographic key sequence is generated using a key remapped to different target values ​​on the FKC system, the same key sequence will produce different outputs at startup, resulting in a password attempt failure. In contrast, the novel implementation described herein is a local firmware-based system that has almost no latency (e.g., <500 μs) between wakeup / startup and FKC implementation, resulting in immediate FKC access, and still adapting to modern device report rates (e.g., 1 ms), thereby contributing to a more reliable, consistent and improved user experience.

[0028] The described implementation provides a comprehensive full-key customization (FKC) framework to address the above-mentioned issues and additional FKC implementation challenges, including logic for managing FKC-based combination key triggering, modifier processing, key combination press / release events, modifier processing when linking combination keys, suppression and re-enabling of modifiers, conflicts, parallel key presses, etc., which will be described in detail below.

[0029] It should be understood that this high level overview is presented to provide the reader with a basic understanding of some of the novel aspects of the present disclosure as well as a road map to the details that follow. This high level overview in no way limits the scope of the various embodiments described throughout the detailed description, and each of the figures referenced above is further described below in greater detail and to the extent appropriate.

[0030] definition

[0031] Full Key Customization (FKC) : This feature allows a user to customize the actions of one or more keys, buttons, rotary devices, etc. on an input device (e.g., a keyboard), such as, for example, remapping one key to another key, or programming a key to play back a macro. The novel implementation of FKC described herein differs from conventional FKC systems in that it can be applied to all keyboard keys (e.g., not just designated programmable keys), and modifier+key combinations can be customized, such as assigning custom behaviors to Ctrl+x, Shift+Ctrl+y, Fn+z, Fn+Ctrl+x, etc.

[0032] Key: This is a physical key or button on an input device (eg, a keyboard).

[0033] Modifiers : is defined as any of the following functions, including: left Shift, right Shift, left Ctrl, right Ctrl, left Alt, right Alt, left GUI (e.g., "Windows" key), right GUI (e.g., "Context Menu" key), keyboard key, but some embodiments may specify other modifier keys. In some aspects, the left modifier key and the right modifier key may not be distinguished, and may be considered equivalent by the host system (and by the user). For example, a shortcut key may be generally designated as "Ctrl+C", and will work identically whether the left or right Ctrl key is used. However, for certain key combination customizations, some embodiments may distinguish between left and right modifiers.

[0034] Logical modifiers: FKC allows the user to remap any physical key (or key combination) to a modifier key. For example, a user can remap "(physical) X" -> (to) "(logical) Left Shift" or "(physical) Left Ctrl" -> "(logical) Right Alt". Such remapping assignments are called "logical" modifiers, as opposed to physical modifier keys, which are mapped to their corresponding logical modifiers by default. Logical modifier values ​​can take into account the pressed state of uncustomized physical modifier keys as well as the pressed state of keys remapped to modifiers via FKC. Logical modifiers are values ​​maintained internally in FW for the purpose of matching key triggers.

[0035] Key Combinations: Also known as a "shortcut key" or "hot key", this is a key combination commonly used in modern operating systems and applications, and generally involves pressing and holding one or more modifiers, and then pressing a single non-modifier key to generate a specific output. Some common examples of key combinations include "Ctrl" + "C" = Copy, and "Ctrl" + "Alt" + "Delete" = Restart or open Task Manager. For the purposes of FKC, key combinations are further defined in a larger context in the embodiments described below.

[0036] Trigger (key / key combination) : A single control key or shortcut key that is assigned a custom behavior when pressed. A custom key or key combination is also called a "trigger" key.

[0037] Goal (action / behavior) : This is the behavior that can be performed when the user presses the trigger key / key combination.

[0038] Remap : The target behavior is different from the default key output for a single key or key combination.

[0039] Macro: A targeted behavior consisting of a series of variable length keystrokes or consumer codes. Macros can also include delays and other behaviors.

[0040] G Keys : The G keys are keys labeled "G1", "G2", etc., which are configured for customization. , but may include any customizable keys.

[0041] System environment

[0042] Figure 1 An example of a computer system 100 is shown that can include any of a variety of host computing devices and computer peripherals, including peripherals (e.g., computer mice, keyboards, etc.) that can be configured to perform aspects of the various inventive concepts described herein; the computer system 100 shows a user 105 operating a host computing device (shown as a desktop computer) 110 and a plurality of computer peripherals that can be coupled and / or integrated with the host computing device, including a display device 120, a computer mouse 130, a keyboard 140, and can include any other suitable computer peripherals (e.g., microphones, speakers, docking stations, headphones, etc.). Each computer peripheral 120-140 can be communicatively coupled to the host computing device 110.

[0043] Although the host computing device is shown as a desktop computer, other types of host computing devices may be used, including gaming systems, laptop computers, set-top boxes, entertainment systems, tablet computers or "tablet" computers, stand-alone head-mounted displays ("HMD"), or any other suitable host computing device (e.g., smart phones, smart wearable devices, etc.). In some cases, multiple host computing devices may be used, and one or more of the computer peripheral devices may be communicatively coupled to one or more of the host computing devices (e.g., a computer mouse may be coupled to multiple host computing devices). The host computing device may also be referred to herein as a "host computer," "host device," "computing device," "computer," etc., and may include a machine-readable medium (not shown) configured to store computer code, such as driver software, firmware, etc., wherein the computer code may be executed by one or more processors in the host computing device to control aspects of the host computing device, such as via one or more computer peripheral devices.

[0044] Typical computer peripherals may include any suitable input device, output device, or input / output device, including devices shown (e.g., a computer mouse) and devices not shown (e.g., a remote control, a wearable device (e.g., a glove, a watch, a head mounted display), an AR / VR controller, a CAD controller, a joystick, an analog shifter, a stylus device, or other suitable devices that can, for example, be used to convert analog input to digital signals for computer processing. By way of example, a computer peripheral (e.g., a computer mouse 130) may be configured to provide for motion tracking (e.g., x-axis on a plane). The computer peripheral device may include control signals (e.g., y movement, three-dimensional "in-air" movement, etc.), touch and / or gesture detection, lift detection, orientation detection (e.g., in a 3-degree-of-freedom (DOF) system, a 6DOF system, etc.), power management functions, input detection (e.g., buttons, scroll wheels, etc.), output functions (e.g., LED control, tactile feedback, etc.), or any of a large number of other features that may be provided by a computer peripheral device, as will be understood by one of ordinary skill in the art. The buttons of computer mouse 130 and the keys of keyboard 140 (or other depressible elements on any input device) may include aspects of full key customization, as presented herein.

[0045] The input device may be a computer peripheral device, and may also be referred to herein as a "peripheral input device," "peripheral device," etc. Most of the embodiments described herein generally refer to computer peripheral device 140, however, it should be understood that the computer peripheral device may be any suitable input / output (I / O) device (e.g., user interface device, control device, input unit, etc.) that may be suitable for utilizing the novel embodiments described and contemplated herein.

[0046] System for operating computer peripheral devices

[0047] Figure 2 A system 200 for operating a computer peripheral device (e.g., a computer mouse 130, a keyboard 140, etc.) according to certain embodiments is shown. The system 200 can be configured to operate any of the computer peripheral devices specifically shown or not shown herein but within the broad scope of the present disclosure. The system 200 may include a processor 210, a memory block 220, a power management block 230, a communication block 240, an input detection block 250, and an output control block 260. Each of the system blocks 220 to 260 can be in electronic communication with the processor 210 (e.g., via a bus system). The system 200 may include additional functional blocks that are not shown or discussed to prevent confusion about the novel features described herein. The system blocks 220 to 260 (also referred to as "modules," "systems," or "system blocks") can be implemented as separate modules, or alternatively, more than one system block can be implemented in a single module. As will be understood by those of ordinary skill in the art with the benefit of the present disclosure, in the context described herein, the system 200 may be included in any computer peripheral device described or mentioned herein, and may also be configured with at least the following description of the system 200. Figures 4 to 12 Any of the full-key customization implementations presented in this document described.

[0048] In some embodiments, the processor 210 may include one or more microprocessors and may be configured to control the operation of the system 200. Alternatively or additionally, the processor 210 may include one or more microcontrollers (MCUs), digital signal processors (DSPs), etc., with supporting hardware and / or firmware (e.g., memory, programmable I / O, etc.) and / or software, as will be understood by those of ordinary skill in the art. The processor 210 may control some or all aspects of the operation of the computer peripherals 140 (e.g., system blocks 220 to 260). Alternatively or additionally, some of the system blocks 220 to 260 may include additional dedicated processors that may work in conjunction with the processor 210. For example, an MCU, μC, DSP, etc. may be configured in other system blocks of the system 200. The communication block 240 may include a local processor, for example, to control various aspects of communication with the host computer 110 (e.g., via Bluetooth, Bluetooth LE, RF, IR, hardwired, ZigBee, Z-Wave, Logitech Unifying, or other communication protocols). Processor 210 may be local to the peripheral device (e.g., contained therein), may be external to the peripheral device (e.g., as processed off-board by a corresponding host computing device), or a combination thereof. Processor 210 may cooperate with any other system blocks in system 200 to perform various functions and methods described and / or covered by the present disclosure (e.g., Figures 4 to 12 In some implementations, Figure 3 The processor 302 can work in conjunction with the processor 210 to perform some or all of the various methods described throughout this disclosure. In some embodiments, multiple processors can achieve increased performance characteristics (e.g., speed and bandwidth) in the system 200, however, multiple processors are not required and are not essential to the novelty of the embodiments described herein. Those of ordinary skill in the art will appreciate that many variations, modifications, and alternative embodiments are possible.

[0049] The memory block ("memory") 220 may store one or more software programs to be executed by the processor (e.g., in the processor 210). It should be understood that "software" may refer to a sequence of instructions that, when executed by a processing unit (e.g., a processor, a processing device, etc.), causes the system 200 to perform certain operations of the software program. The instructions may be stored as firmware residing in a read-only memory (ROM) and / or an application stored in a media storage device, which may be read into the memory for execution by the processing device (e.g., the processor 210). The software may be implemented as a single program or a collection of separate programs, and may be stored in a non-volatile storage device and copied in whole or in part to a volatile working memory during program execution. In some embodiments, the memory 220 may store data corresponding to inputs on a peripheral device, such as detected movement of a peripheral device sensor (e.g., an optical sensor, an accelerometer, etc.), activation of one or more input elements (e.g., a button, a slider, a touch-sensitive area, etc.), etc. The stored data may be aggregated and sent to a host computing device via a report.

[0050] In some embodiments, the memory 220 may store various data described throughout the present disclosure. For example, the memory 220 may store and / or include instructions configured to execute various FKC control schemes presented herein. The memory 220 may be used to store any suitable data to perform any function described herein and as will be understood by a person of ordinary skill in the art with the benefit of the present disclosure. The memory array 220 may be referred to as a storage system or storage subsystem, and may store one or more software programs to be executed by a processor (e.g., in the processor 210). It should be understood that "software" may refer to a sequence of instructions that causes the system 200 to perform certain operations of a software program when executed by a processing unit (e.g., a processor, a processing device, etc.). The instructions may be stored as firmware residing in a read-only memory (ROM) and / or an application stored in a media storage device, which may be read into the memory for processing by the processing device. The software may be implemented as a single program or a collection of separate programs, and may be stored in a non-volatile storage device and copied in whole or in part to a volatile working memory during program execution. The processing device may retrieve program instructions to be executed from the storage subsystem to perform various operations as described herein (eg, software controlled switches, etc.).

[0051] The power management system 230 can be configured to manage power distribution, recharging, power efficiency, haptic motor power control, etc. In some embodiments, the power management system 230 may include a battery (not shown), a universal serial bus (USB)-based recharging system (not shown) for the battery, and a power management device (e.g., a voltage regulator—not shown) and an electrical grid within the system 200 for providing power to each subsystem (e.g., the communication block 240, etc.). In some embodiments, the functionality provided by the power management system 230 may be incorporated into the processor 210. Alternatively, some embodiments may not include a dedicated power management block. For example, functional aspects of the power management block 240 may be included or combined with another block (e.g., the processor 210). The power source may be a replaceable battery, a rechargeable energy storage device (e.g., a supercapacitor, a lithium polymer battery, NiMH, NiCd), a wired power supply, or other suitable power source. The recharging system may be an additional cable (dedicated to the purpose of recharging), or the recharging system may use a USB connection to recharge the battery.

[0052] According to some embodiments, the communication system 240 may be configured to implement wireless communication with a corresponding host computing device (e.g., 110) or other devices and / or peripheral devices. The communication system 240 may be configured to provide radio frequency (RF), Logitech proprietary communication protocols (e.g., Unifying, Gaming Lightspeed, or others), infrared (IR), Z-Wave or other suitable communication technology for communicating with other computing devices and / or peripheral devices. System 200 may optionally include a hardwired connection to a corresponding host computing device. For example, input device 130 may be configured to receive USB, Or other general types of cables to achieve two-way electronic communication with the corresponding host computing device or other external devices. Some embodiments may utilize different types of cables or connection protocol standards to establish hard-wired communication with other entities. In some aspects, communication ports (e.g., USB), power ports, etc. may be considered as part of other blocks (e.g., input detection module 250, output control module 260, etc.) described herein. In some aspects, communication system 240 may send reports (e.g., HID data, streaming or aggregated data, etc.) generated by processor 210 to the host computing device. In some cases, the report may be generated only by the processor, in collaboration with the processor or other entities in system 200. Communication system 240 may include one or more antennas, oscillators, etc., and may operate at any suitable frequency band (e.g., 2.4 GHz), etc. Those of ordinary skill in the art will understand many modifications, variations, and alternative embodiments of the present disclosure with the benefit of the present disclosure.

[0053] The input detection module 250 may control the detection of user interactions with input elements (also referred to as "elements") on an input device. For example, as will be appreciated by one of ordinary skill in the art with the benefit of this disclosure, the input detection module 250 may detect user input from a key or button (e.g., a depressible element), a scroll wheel, a motion sensor, a scroll wheel, a trackball, a touch pad (e.g., a one-dimensional and / or two-dimensional touch-sensitive touch pad), a click wheel, a dial, a keypad, a microphone, a GUI, a touch-sensitive GUI, a proximity sensor (e.g., IR, thermal, Hall effect, inductive sensing, etc.), image sensor-based detection such as gesture detection (e.g., via a webcam), audio-based detection such as voice input (e.g., via a microphone), etc. Alternatively, the functionality of the input detection module 250 may be included by or combined with the processor 210.

[0054] In some embodiments, the input detection module 250 can detect a touch or touch gesture on one or more touch-sensitive surfaces on the input device 130. The input detection block 250 may include one or more touch-sensitive surfaces or touch sensors. A touch sensor typically includes a sensing element suitable for detecting a signal such as direct contact, an electromagnetic field or an electrostatic field, or an electromagnetic radiation beam. A touch sensor can typically detect a change in a received signal, the presence of a signal, or the absence of a signal. The touch sensor may include a source for transmitting the detected signal, or the signal may be generated by a secondary source. The touch sensor may be configured to detect the presence of an object at a certain distance from a reference area or point (e.g., <5 mm), the presence of an object in contact with a reference area or point, or a combination thereof. Certain embodiments of the computer peripheral device 150 may or may not utilize touch detection or touch sensing capabilities.

[0055] The input detection block 250 may include touch and / or proximity sensing capabilities. Some examples of types of touch / proximity sensors may include, but are not limited to, resistive sensors (e.g., based on standard air gap 4-wire, based on carbon-supported plastics with different electrical properties depending on pressure (FSR), interpolated FSR, strain gauges, etc.), capacitive sensors (e.g., surface capacitance, self-capacitance, mutual capacitance, etc.), optical sensors (e.g., light barrier type (open or closed by default), infrared light barrier matrix, laser-based diodes coupled to photodetectors that can measure the time of flight of light paths, etc.), acoustic sensors (e.g., piezoelectric buzzers coupled to microphones to detect modifications of wave propagation modes associated with touch points, etc.), inductive sensors, magnetic sensors (e.g., Hall effect, etc.), etc.

[0056] In some embodiments, the output control module 260 can control various outputs for corresponding computer peripheral devices. For example, the output control module 260 can control multiple visual output elements (e.g., LEDs, LCD screens), displays, audio outputs (e.g., speakers), tactile output systems, etc. Those of ordinary skill in the art will appreciate many modifications, variations, and alternative embodiments of the present disclosure with the benefit of this disclosure.

[0057] As will be understood by those of ordinary skill in the art, although some systems may not be explicitly discussed, these systems should be considered as part of system 200. For example, system 200 may include a bus system to transmit power and / or data to and from different systems therein. It should be understood that system 200 is illustrative, and variations and modifications are possible. System 200 may have other capabilities not specifically described herein. In addition, although system 200 is described with reference to specific blocks, it should be understood that these blocks are defined for ease of description and are not intended to imply a specific physical arrangement of the components. In addition, blocks do not need to correspond to physically different components. Blocks may be configured to perform various operations, for example, by programming a processor or providing appropriate control circuitry, and various blocks may or may not be reconfigurable depending on how the initial configuration is obtained.

[0058] Embodiments of the present invention may be implemented in various devices including electronic devices (e.g., computer peripherals) implemented using any combination of circuit systems and software. In addition, various aspects and / or parts of system 200 may be combined with other subsystems or operated by other subsystems according to design needs. For example, input detection block 250 and / or memory 220 may operate within processor 210 rather than being used as separate entities. In addition, the inventive concepts described herein may also be applied to any electronic device. In addition, system 200 may be applied to any of the computer peripherals described in the embodiments herein, whether explicitly, by reference, or by default described computer peripherals (e.g., those of ordinary skill in the art are known to be applicable to specific computer peripherals). The foregoing embodiments are not intended to be limiting, and those of ordinary skill in the art will understand numerous applications and possibilities with the benefit of this disclosure.

[0059] System for operating a host computing device

[0060] Figure 3 300 is a simplified block diagram of a host computing device 300 according to certain embodiments. The host computing device 300 may implement some or all of the above functions, behaviors and / or capabilities that will use electronic storage or processing, as well as other functions, behaviors or capabilities that are not explicitly described. The host computing device 300 may include a processing subsystem (processor) 302, a storage subsystem 306, user interfaces 314, 316, and a communication interface 312. The computing device 300 may also include other components (not explicitly shown) that are operable to provide various enhanced capabilities, such as batteries, power controllers, and other components. In various embodiments, the host computing device 300 may be implemented in any suitable computing device, such as a desktop or laptop computer (e.g., desktop 110), a mobile device (e.g., a tablet computer, a smart phone, a mobile phone), a game console, a wearable device, a media device, etc., or in some implementations in a peripheral device (e.g., a keyboard, etc.).

[0061] Processor 302 may include an MCU, a microprocessor, an application specific integrated circuit (ASIC), a digital signal processor (DSP), a digital signal processing device (DSPD), a programmable logic device (PLD), a field programmable gate array (FPGA), a processor, a controller, a microcontroller, a microprocessor, or an electronic unit designed to perform the functions or methods described throughout the present disclosure, a combination of functions, etc.

[0062] The storage subsystem 306 may be implemented using local storage and / or removable storage media, such as using a disk, flash memory (e.g., a secure digital card, a universal serial bus flash drive), or any other non-transitory storage medium or combination of media, and may include volatile and / or non-volatile storage media. The local storage may include a memory subsystem 308, which includes a random access memory (RAM) 318 such as a dynamic RAM (DRAM), a static RAM (SRAM), a synchronous dynamic RAM (e.g., DDR), or a battery-backed RAM, or a read-only memory (ROM) 320, or a file storage subsystem 310 that may include one or more code modules. In some embodiments, the storage subsystem 506 may store one or more applications and / or operating system programs to be executed by the processing subsystem 302, including programs to be executed using a computer for implementing some or all of the operations described above. For example, the storage subsystem 306 may store one or more code modules for implementing one or more method steps described herein.

[0063] Modules (e.g., procedures, functions, etc.) may be utilized to implement firmware and / or software implementations. Machine-readable media that tangibly implement instructions may be used in implementing the methods described herein. Code modules (e.g., instructions stored in memory) may be implemented within a processor or external to a processor. As used herein, the term "memory" refers to a type of long-term, short-term, volatile, non-volatile, or other storage medium, and is not limited to any particular type of memory or any number of memories, or the type of medium on which the memory is stored.

[0064] In addition, the term "storage medium" or "storage device" may refer to one or more memories for storing data, including read-only memory (ROM), RAM, magnetic RAM, magnetic core memory, magnetic disk storage media, optical storage media, flash memory devices and / or other machine-readable media for storing information. The term "machine-readable medium" includes, but is not limited to, portable or fixed storage devices, optical storage devices, wireless channels and / or various other storage media capable of storing instructions and / or data.

[0065] In addition, implementation methods can be implemented by hardware, software, scripting language, firmware, middleware, microcode, hardware description language and / or any combination thereof. When implemented with software, firmware, middleware, scripting language and / or microcode, the program code or code segment for performing tasks can be stored in a machine-readable medium such as a storage medium. Code segments (e.g., code modules) or machine-executable instructions can represent a combination of processes, functions, subroutines, programs, routines, subroutines, modules, software packages, scripts, classes or instructions, data structures and / or program statements. Code segments can be coupled to another code segment or hardware circuit by transmitting and / or receiving information, data, arguments, parameters and / or memory contents. Information, arguments, parameters, data, etc. can be transmitted, forwarded or sent by appropriate means, including memory sharing, message passing, token passing, network transmission, etc. These descriptions of software, firmware, storage media, etc. are applicable to any other implementations in the wide range of systems 200 and 300 and the present disclosure. In some embodiments, aspects of the invention (e.g., surface classification) may be performed by software stored in the storage subsystem 306, in the computer peripheral device's memory 220, or in both. Many modifications, variations, and alternative embodiments of the present disclosure will be apparent to those of ordinary skill in the art having the benefit of this disclosure.

[0066] The implementation of the techniques, blocks, steps, and means described throughout this disclosure may be accomplished in various ways. For example, the techniques, blocks, steps, and means may be implemented in hardware, software, or a combination thereof. For hardware implementations, the processing unit may be implemented within one or more ASICs, DSPs, DSPDs, PLDs, FPGAs, processors, controllers, microcontrollers, microprocessors, other electronic units designed to perform the above functions, and / or combinations thereof.

[0067] Each code module may include an instruction (code) set implemented on a computer-readable medium that directs the processor of the host computing device 110 to perform corresponding actions. The instructions may be configured to run in a sequential order, in parallel (e.g., under different processing threads), or in a combination thereof. After the code module is loaded onto a general-purpose computer system, the general-purpose computer is converted into a special-purpose computer system.

[0068] Computer programs incorporating the various features described herein (e.g., in one or more code modules) may be encoded and stored on various computer-readable storage media. Computer-readable media encoded with program code may be packaged with a compatible electronic device, or the program code may be provided separately from the electronic device (e.g., downloaded via the Internet or as a separately packaged computer-readable storage medium). Storage subsystem 306 may also store information useful for establishing a network connection using communication interface 312.

[0069] The computer system 300 may include user interface input device 314 elements (e.g., touch pad, touch screen, scroll wheel, click wheel, dial, button, switch, keypad, microphone, etc.), and user interface output device 316 (e.g., video screen, indicator light, speaker, headphone jack, virtual reality or augmented reality display, etc.), together with supporting electronic devices (e.g., digital-to-analog converter or analog-to-digital converter, signal processor, etc.). A user can operate the user interface input device 314 to invoke functions of the computing device 300, and can see and / or hear output from the computing device 300 via the user interface output device 316.

[0070] The processing subsystem 302 can be implemented as one or more processors (e.g., integrated circuits, one or more single-core or multi-core microprocessors, microcontrollers, central processing units, graphics processing units, etc.). In operation, the processing subsystem 302 can control the operation of the computing device 300. In some embodiments, the processing subsystem 302 can execute various programs in response to program code, and can maintain multiple programs or processes that are executed simultaneously. At a given time, some or all of the program code to be executed can reside in the processing subsystem 302 and / or in a storage medium (e.g., storage subsystem 304). Through programming, the processing subsystem 302 can provide various functions for the computing device 300. The processing subsystem 302 can also execute other programs for controlling other functions of the computing device 300, including programs that can be stored in the storage subsystem 304.

[0071] The communication interface (also referred to as a network interface) 312 can provide voice and / or data communication capabilities for the computing device 300. In some embodiments, the communication interface 312 may include a radio frequency (RF) transceiver component for accessing a wireless data network (e.g., a Wi-Fi network; 3G, 4G / LTE, etc.), a mobile communication technology, a component for short-range wireless communication (e.g., using the Bluetooth communication standard, NFC, etc.), a combination of other components or technologies. In some embodiments, in addition to or instead of a wireless interface, the communication interface 312 may also provide a wired connection (e.g., a universal serial bus (USB), Ethernet, a universal asynchronous receiver / transmitter, etc.). The communication interface 312 can be implemented using a combination of hardware components (e.g., driver circuits, antennas, modulators / demodulators, encoders / decoders, and other analog signal processing circuits and / or digital signal processing circuits) and software components. In some embodiments, the communication interface 312 can support multiple communication channels simultaneously.

[0072] User interface input devices 314 may include any suitable computer peripheral device (e.g., a computer mouse, keyboard, game controller, remote control, stylus device, etc.), as will be appreciated by one of ordinary skill in the art having the benefit of this disclosure. User interface output devices 316 may include display devices (e.g., monitors, televisions, projection devices, etc.), audio devices (e.g., speakers, microphones), haptic devices, etc. Note that user interface input devices and output devices are shown as part of system 300 as an integrated system. In some cases, such as in a laptop computer, this may be the case where the keyboard and input elements and the display and output elements are integrated on the same host computing device. In some cases, such as Figure 1 As shown, the input devices and output devices may be separate from the system 300. Many modifications, variations, and alternative embodiments of the present disclosure will occur to those of ordinary skill in the art having the benefit of this disclosure.

[0073] It will be understood that computing device 300 is illustrative, and variations and modifications are possible. The host computing device may have various functions (e.g., voice communication via a cellular telephone network) that are not specifically described, and may include components suitable for such functions. Although computing device 300 is described with reference to specific blocks, it should be understood that these blocks are defined for ease of description and are not intended to imply a specific physical arrangement of the components. For example, processing subsystem 302, storage subsystem 306, user interface 314, 316, and communication interface 312 may be in one device or distributed in multiple devices. In addition, blocks do not need to correspond to physically different components. Blocks may be configured to perform various operations, such as by programming a processor or providing appropriate control circuit systems, and various blocks may or may not be reconfigurable depending on how the initial configuration is obtained. Embodiments of the present invention may be implemented in various devices, including electronic devices implemented using a combination of circuit systems and software. System 300 may be used to implement the host computing device or even peripheral devices described herein.

[0074] Full key customization

[0075] As described above, aspects of the present invention relate to input devices with an onboard system (e.g., firmware) to implement fully customizable keys, buttons, and shortcuts, which is made possible by assigning new target behaviors to specific trigger keys via local processing (e.g., firmware) using a novel processing method further described below. The remapped target data is sent to a communicatively coupled host computing device in a manner that results in excellent low latency (e.g., sub-millisecond reporting), accuracy, reliability, and consistency (e.g., FKC is applied immediately upon wakeup / power-up), thereby facilitating an improved UX.

[0076] The following embodiments described provide a novel and comprehensive full key customization (FKC) framework to solve the above problems and other FKC implementation challenges, including management of FKC-based combination key triggering, modifier processing, key combination pressing / releasing events, modifier processing when linking combination keys, suppression and re-enabling of modifiers, conflicts, parallel key presses, etc., which will be described in detail below. At a high level, FKC distinguishes three independent layers, including the base layer, the FN layer, and the GShift layer, each of which has similar behaviors and capabilities. As will be understood by those of ordinary skill in the art with the benefit of this disclosure, some embodiments may have fewer or more layers. Within each layer, the trigger key can be of two types, including a single key and a combination key. The target action / behavior can be of multiple types, including remapping to another key or shortcut key, macro, button press, etc. The modifier specified in the target action can be optionally used to update a list of pressed logical modifiers. In doing so, the trigger key can be used to press one or more logical modifiers, which in turn can be used to build a trigger shortcut key. Triggering key press and key release events may optionally be notified to software operating on a host computing device ("Host SW"). This may be used, for example, to implement targeted actions in the Host SW. In some aspects, GShift and FN may be supported as system-wide layer selectors, meaning that a user may press GShift on one device (e.g., computer mouse 130) and expect GShift layer behavior when pressing a key on a second device (e.g., keyboard 140).

[0077] Figure 4 An example of a base layer, FN layer, and GShift layer in an input device (e.g., keyboard 400, 140) utilizing an FKC system according to some embodiments is shown. Base layer 410 includes keys that are directly accessible without pressing a layer modifier (e.g., FN, GShift). FN layer 420 is keys that are accessible when the FN modifier is pressed, also known as a "function key" layer. GShift layer 430 is keys that are accessible when the GShift modifier is pressed. Figure 4 , assign the same keys on the base and GShift layers instead of the FN layer.

[0078] Figure 5 and Figure 6 4 shows the logical results of certain key press combinations on an FKC-enabled keyboard 400 according to certain embodiments. Figure 5, flowchart 500 shows that a user presses the "s" key (operation 502). The FKC keyboard 400 determines that the user assigned the "s" key on the base layer to a different target (operation 504). That is, the "s" key on the base layer is a trigger, and the target is something other than the default "s" alphanumeric character, because, for example, the user may have programmed the key to a different function (e.g., turning on a communicatively coupled lighting device). Therefore, when the "s" key of the base layer 410 is pressed, the user assignment on the base layer is activated (operation 506). If the "s" key on the base layer has not been customized, the default target output (also known as "out-of-the-box" or "OOB" behavior) is executed (operation 508).

[0079] Flowchart 520 shows a user pressing a combination of an “FN” key and an “s” key (operation 522). At operation 524, the FKC keyboard 400 determines that the user has not assigned the “s” key on the FN layer to a different target, and that the default combination (OOB) is programmed to select “Onboard 1”, which corresponds to a manual selection of one or more host computing devices communicatively coupled to the keyboard 400 (e.g., Onboard 1, 2, 3 can cause the keyboard 400 to switch to a different corresponding host computing device) (operation 524). That is, the combination of the “s” key and the “FN” key on the FN layer is not a user-programmed trigger, and the target is the default instruction (Onboard 1) corresponding to the selection of the host computing device. Therefore, when the “s” key of the FN layer 420 is pressed, the user assignment on the FN layer is not activated (operation 526), ​​and the default assignment of “FN+s” is output (operation 527). If there is no user customization for the "s" key on the FN layer, and there is no default value as assigned to this combination, then either nothing happens or the system can revert to the default base layer (eg, alphanumeric "s" output) (operation 528).

[0080] exist Figure 6 , flowchart 600 shows a user pressing a combination of a "GShift" key and an "s" key (operation 602). At operation 604, the FKC keyboard 400 determines that the user has assigned the "s" key on the GShift layer to a different target. That is, the "s" key on the GShift layer is a trigger, and the target is to turn off the output of the communicatively coupled lighting device. Therefore, when the "s" key of the GShift layer 430 is pressed, the user assignment on the GShift layer is activated (operation 606). If the "s" key on the Gshift layer is not customized, the default target output (also referred to as "out of the box" or "OOB" behavior) is executed (operation 608). In some cases, if no GShift OOB assignment is applicable, the system can revert to the OOB base layer assignment (e.g., alphanumeric "s" output).

[0081] Flowchart 620 illustrates a user pressing a combination of the “GShift” key, the “FN” key, and the “s” key (operation 622). At operation 624, the FKC keyboard 400 determines that the user assigned the “s” key on the GShift layer to a different target. Additionally, since both the GShift layer and the FN layer are enabled, the GShift layer is applicable, but some implementations may differ in the hierarchy of modifiers. Thus, the “s” key on the GShift layer is a trigger, the FN layer is ignored, and the target is to turn off the output of the communication-coupled lighting device. Thus, when the “s” key of the GShift layer 430 is pressed, the user assignment on the GShift layer is activated (operation 626). As described above, in some cases, if no GShift OOB assignment is applicable, the system can revert to the OOB base layer assignment of the “s” output (operation 628).

[0082] FKC Implementation

[0083] In order to provide a robust, FW-based FKC implementation that delivers consistent performance across a wide range of applications with excellent latency and instant FKC functionality at startup / wake-up, many engineering challenges need to be addressed, including defining widely used key combination triggers, modifier handling (e.g., inhibition and re-enabling), key combination press and release events, chaining key combinations, conflicts, etc., which will be addressed separately below.

[0084] Define key combination trigger

[0085] In the context of FKC, a combination key trigger can be specified as a combination of one or more logical modifier keys (e.g., left Shift) and any single physical key / button (e.g., the "s" key). A combination key trigger occurs when a user presses a specified single physical key / button while the specified logical modifier key is being held down. Thus, for example, a user should expect to be able to customize the following key trigger / target mappings:

[0086] 1. Remap "(Logical) Left Shift" + "x" → "1"

[0087] 2. Remap “(logical) Left Shift” + “(logical) Right Alt” + “x” → “2”

[0088] 3. Remap "(Logical) Left Shift" + "x" → "Left Ctrl"

[0089] Less intuitively, this can also be customized by the user:

[0090] 4. Remap "(logical) left Shift" + "(physical) left Alt" → "x"

[0091] 5. Remap “(Logical) Left Shift” + “(Physical) Volume Up (Button)” → “y”

[0092] Examples #4 and #5 are valid key combinations for FKC purposes because the key combination can be built on any physical key or button, even if that physical key is a physical modifier key (in this example: Left Alt) or a physical button.

[0093] Modifier handling (modifier suppression)

[0094] In some embodiments, a user can remap a "combination key" (e.g., a modifier + key combination) to any other key or key sequence. The design parameter is that this should work with any number of modifiers. The challenge with Example 1 (above) is that if the "x" key is intercepted and replaced with a "1" key, then the output will be Shift+"1", which will produce "!" (on a US keyboard) instead of "1". Therefore, a different way is needed to disable a modifier key that has been held down by the user.

[0095] One option is to defer sending the modifiers to the host until it is determined that the underlying key combination is not customized. This approach is not optimal because it affects keyboard behavior extensively, even if the user does not press a customized key or shortcut. In other words, modifier keys may be suppressed even when non-customized key triggers are being used, which may significantly affect the latency of the FKC system. In addition, some applications (e.g., games) use modifier key events directly, so not sending modifier key events immediately is unacceptable to many contemporary users.

[0096] The better option (and used in FKC) is to send the modifier immediately after the press, but if the underlying key combination is subsequently determined to be custom, then suppress the modifier manually. In a preferred embodiment, the manual suppression of modifiers should be done directly by the device itself, rather than via SW running on the host computing device, because for many gaming applications, the remap target key must be sent with minimal latency, and the modifier should be suppressed before the remap target key is sent. Furthermore, it may be technically infeasible for the host SW to continuously inject key release signals with the aid of a "virtual" keyboard that will reliably suppress the modifiers.

[0097] In some implementations, if the remap target contains a modifier that also exists in a custom key combination, the modifier is not suppressed by FKC. For example, if the user customized "left Ctrl" + "c" → "left Ctrl" + "x", then the "left Ctrl" modifier should not be suppressed.

[0098] Combination of key press and release events

[0099] When supporting combination key triggers, the challenge is to determine when a combination key is considered to have been "pressed" and "released", and when the corresponding remap target is "pressed" and "released". Note that combination keys are based on multiple underlying key presses: logical modifier keys and primary physical keys. In FKC, a combination key press occurs when a non-modifier key (e.g., a primary physical key) is pressed, and a release occurs when the same non-modifier key is released. In some embodiments, releasing a modifier key does not release the underlying combination key trigger. Similarly, releasing a logical layer selection key (e.g., logical FN and logical GShift) does not release the underlying combination key (or single key) trigger.

[0100] Modifier handling (linking key combinations)

[0101] In some cases, a user may wish to "chain" key combinations. For example, a user may wish to execute a copy / paste command in rapid succession by pressing "Ctrl+C" and "Ctrl+V" in sequence, without releasing and re-pressing the Ctrl key between each key combination. In some key chain combinations, some key combinations may be customized, while other key combinations may not be customized. This has several implications. If the FKC system ("FKC") artificially suppresses a modifier, and the user presses a non-customized key combination, the FKC will need to unsuppress it. The FKC also needs to keep track of a "logical" modifier state that is separate from the modifier press / release signal sent to the host computer ("host") OS.

[0102] Unsuppress modifiers

[0103] In some embodiments, when the user releases the underlying physical trigger key, the de-suppression modifier may occur. However, this is not a preferred option, particularly when the target key is a macro, or if it is a remapping implemented in the host SW, because the macro (or host SW remapping) may take too much time to execute. If FKC de-suppresses the modifier in the early stage, it will likely interfere with the delayed execution of the macro / remapping function. For example, if the user configures "left Ctrl" + "x" → "a, b, c, d, e, f" (macro), then when the user presses "x" while the logical left Ctrl is being pressed, FKC will suppress the left Ctrl modifier and start the execution of the macro. The user will release "x" later, and if the left Ctrl is de-suppressed immediately, the macro may be affected, so that the OS may interpret the sequence as: "a", "b", "left Ctrl+c", "left Ctrl+d", "left Ctrl+e", "left Ctrl+f", rather than the correct "a, b, c, d, e, f" output.

[0104] A better option is to configure FKC so that modifier unsuppression should not occur when "x" is released, but only if / when the user presses a subsequent key. For example, consider the following sequence: (1) user presses and holds "left Ctrl"; (2) user presses "x" → FKC suppresses left Ctrl and starts the macro; (3) user releases "x"; and (4) user presses "y" → FKC unsuppresses "left Ctrl" and sends "y".

[0105] conflict

[0106] When a user presses a modifier key during macro playback, a conflict may occur, resulting in undesired behavior. In some cases, conflicts with remapping may also occur when implemented via the host SW rather than on a computer peripheral device (e.g., via FW) because, as described above, the relative timing of local keys and keys injected by the host SW may conflict due to communication delays. For example, a user may configure "a" to be remapped to "x". In the host SW implementation, if the user then presses and releases "a", and immediately presses "Left Shift", the injection of "x" may be delayed to a time after pressing "Left Shift", resulting in an unexpected uppercase "X" output. In addition, the "unsuppression" of modifiers may also cause conflicts in the host SW implementation of the key remapping system.

[0107] Some general design guidelines that can help minimize the risk of conflicts include implementing remapping locally on the computer peripheral (e.g., local FW-based FKC), implementing macros on the computer peripheral ("input device") if possible (e.g., to minimize latency), and unsuppressing modifiers when the user presses a subsequent key. In some implementations, the user can mark a macro so that the input device blocks all other key and modifier keys until the macro has completed, and so that the macro should immediately stop executing once the user presses another key.

[0108] Parallel Keys

[0109] Parallel keypresses occur when a user presses and releases different keys that are remapped to the same target key. Aspects of FW-based FKC can address this situation in a more reliable and consistent manner than conventional systems. For example, a user can remap: "a" → "x" and "b" → "x". Consider the following sequence: (1) user presses and holds "a" → device sends "x"; (2) user presses "b" → no action ("x" has already been sent); and (3) user releases "b" → result? Some options include causing "x" to be released immediately, or waiting until the user releases "a". Some exemplary FKC implementations release the target once the user releases either of the trigger keys.

[0110] Implicit trigger matching

[0111] In some embodiments, FKC UX is configured so that if a user remaps a single trigger key to a single target key, remapping occurs even if the user holds down one or more modifiers when pressing the trigger key. This is called an "implicit" trigger match, which is different from an explicit match that will have an exact match of all trigger keys including modifier keys. For example, if a user remaps "a" → "x", the expectation is that pressing "Shift" + "a" should cause "Shift" + "x" (capital X). In some aspects, implicit trigger matching may not be applicable between layers. Therefore, in the above example, if a user presses "Fn" + "a", or "G-Shift" + "a", no match will be generated implicitly or otherwise. More generally, FKC can be configured so that when a user has specified a combination key trigger (in this case only exact matching is applicable), or when the target is not a single key (e.g., the target is a macro), implicit matching does not occur. However, some embodiments may adopt a more flexible strategy, in which implicit trigger matching can be applicable to any type of trigger / target, including macros.

[0112] Notify host computing device SW

[0113] In some embodiments, some customized behaviors may need host SW to perform.For example, injecting emoticons or starting specific applications or games will involve host SW.Therefore, the various aspects of the FKC based on FW provide a flexible way of pressing and releasing the key trigger (for example, single key or key combination) of notifying host SW of specific customization.Reiterate the substantial importance of time delay in FKC, and assume that the user can press multiple keys, with the FKC implementation called as dual event system, a flexible system for sending multiple notifications in parallel to host SW, the dual event system includes an event system based on bit fields and a system based on lists, in the event system based on bit fields, each bit represents the different triggers in the FKC setting table (also referred to as key remapping database), and in the system based on lists, each trigger event is represented by a separate byte.When there are several keys pressed simultaneously, a method based on lists can be used.The short HID++ message produced can be carried on the bottom HID message.For the situation of pressing more customized keys, the bit field method can support up to 128 simultaneous key events. As will be appreciated by one of ordinary skill in the art having the benefit of this disclosure, some implementations may use only one of the two systems, and some bit fields may support other total simultaneous key events.

[0114] Layered design

[0115] In some embodiments, multiple layers are implemented in FKC. As described above, the three layers include a base layer, an FN layer, and a GShift layer. The layer that is applied depends on whether a logical Fn key or a logical GShift key is pressed at the time and which of the logical Fn key or the logical GShift key is pressed. In some cases, the GShift layer can be applied across multiple devices (e.g., a user can assign a button on the mouse 130 to GShift, which can enable GShift on the keyboard 140). In some embodiments, implicit matching can be applied within a given layer rather than between layers. Each layer can be configured via a similar configuration table (e.g., a key remapping database, and see Figure 8 ) and are fully interchangeable. In some cases, if not customized, a layer can have a specific default behavior, such as Figure 7 shown.

[0116] Figure 7700 is a simplified flow chart illustrating aspects of a method 700 for FKC triggered matching according to certain embodiments. The method 700 may be performed by processing logic, which may include hardware (circuitry, dedicated logic, etc.), software operating on appropriate hardware (e.g., a general purpose computing system or a dedicated machine), firmware (embedded software), or any combination thereof. In certain embodiments, the method 700 may be performed by aspects of the system 200 (e.g., the processor 210 and the memory block 220), the system 300, or a combination thereof.

[0117] At operation 710, method 700 may include determining whether a logical GShift is pressed, and when true, in the FKC GShift layer table (see, e.g., Figure 8 ) for a match (operation 720). At operation 730, when a match is found, the FKC implements (e.g., sends the key target to the host computing device) the remapped key target indicated in the GShift layer table 810 (operation 770). At operation 730, when no match is found, the default (OOB) base layer is searched and the corresponding assignment is sent to the host computing device.

[0118] At operation 710, when the logical GShift is false (not pressed), the method 700 continues by determining whether the logical FN is pressed (operation 715). When true, the method 700 includes in the FKC FN layer table (see, e.g. Figure 8 ) to search for a corresponding group for a match (operation 722). At operation 732, when a match is found, the FKC implements the remap key target indicated in the FN layer table 820 (operation 770). At operation 732, when a match is not found, the default (OOB) FN layer is searched (operation 740). At operation 750, when a match is found, the FKC continues to send the corresponding allocation to the host computing device. At operation 750, when a match is not found, the default (OOB) base layer is searched (operation 760), and the corresponding allocation is sent to the host computing device.

[0119] At operation 516 , when the logical FN is false (not pressed), the method 700 continues to search the FKC base table for the corresponding group (operation 724 ).

[0120] At operation 734, when a match is found, the FKC implements the remap key target indicated in the FN layer table 830 (operation 770). At operation 734, when no match is found, the default (OOB) FN layer is searched (operation 740).

[0121] It should be understood that Figure 7The specific steps shown provide a specific method 700 for FKC trigger matching according to certain embodiments. Other step sequences may also be performed according to alternative embodiments. In addition, additional steps may be added or removed according to specific applications. Any combination of variations may be used, and those of ordinary skill in the art will appreciate many variations, modifications, and alternative embodiments of the present disclosure with the benefit of this disclosure.

[0122] Figure 8 A lookup table 800 for multiple layers in an FKC-enabled input device according to certain embodiments is shown. Table 800 includes a FKC GShift layer table 810, a FKC FN layer table 820, and a FKC base layer table 830. The table for each layer includes a trigger matrix and a target matrix. The trigger matrix stores a number of FKC triggers (e.g., user defined), which include one or more logical modifiers and non-modifiers. The target matrix stores corresponding FKC targets, which include any combination of modifiers and non-modifiers (e.g., HID commands). Each trigger / target set can be indexed to enable searching.

[0123] Notify SW of trigger key press and release

[0124] Many FKC target behaviors can be implemented in the input device itself, however, some FKC target behaviors cannot be implemented in the input device itself because these FKC target behaviors require the host SW to execute (e.g., emoticons, launching applications, etc.). In some cases, some applications can be enabled by allowing the host SW to know to press and release specific trigger keys. Therefore, some embodiments may adopt the following FKC strategies: the host SW can configure the device to send a notification when the user presses and releases any FKC trigger; the host SW can configure the FKC trigger to not have a local target behavior; and / or the notification can occur in parallel with the local target behavior. In some aspects, the key remapping database can be used with the help of a table in the host SW (see, for example Figure 8 ) to configure FKC. Each row in the table can contain a specific key trigger and associated behavior. In some embodiments, the host SW can assign an arbitrary trigger index to each row, which can be used to identify the trigger when notifying the host SW. In some cases, two types of events are supported, including short events and long events. When a low number of trigger keys are being pressed (e.g., <= 3), a short event is applied, which can be piggybacked on the underlying HID event to avoid introducing any additional delays. If a relatively high number of trigger keys are being pressed (e.g., >3), a long event format of a bit field type can be used, which can simultaneously notify the host SW of up to 128 separate trigger key presses and releases, which allows the FKC system to always maintain at least 26 key rollovers.

[0125] Enable / disable FKC

[0126] In FKC UX, users can use the host SW (e.g. Logitech ) or by pressing the FKC switching hotkey on the corresponding input device to enable and disable FKC. When the user disables FKC, the input device FW can completely avoid FKC processing.

[0127] Input device and host computer FKC implementation

[0128] Figures 9 to 11 The following flow chart shows an example of how an FKC-enabled input device can generate both default output and FKC output in a low-latency, consistent, and reliable manner utilizing the novel FKC innovations described above.

[0129] Fig. 9 9 is a simplified flow chart illustrating aspects of a method 910 for remapping keys on an FKC-enabled input device (e.g., keyboard 140, 400) according to certain embodiments. The method 910 may be performed by processing logic, which may include hardware (circuitry, dedicated logic, etc.), software operating on appropriate hardware (e.g., a general-purpose computing system or a dedicated machine), firmware (embedded software), or any combination thereof. In certain embodiments, the method 910 may be performed by a system 200 (e.g., a processor 210 and memory 220 for a device 940 (e.g., keyboard 140, 400)), a system 300 (e.g., a processor 302 and memory storage subsystem 306 for a host computing device 110), or a combination thereof.

[0130] Method 910 shows a flow chart for remapping key triggers to key targets in an FKC-enabled input device. In particular, the flow chart shows a sequence of events for remapping "left Shift" + "x" (key trigger) → "left Ctrl" + "y" (key target). The FKC table 900 of the key remapping database includes key trigger 902 and key target 904 lookup tables that identify various logical / HID modifier bitmaps, physical keys, corresponding flags and actions, etc., for the FKC-enabled input device to identify the expected trigger / target pair.

[0131] Referring back to method 910, user 920 may be a person, AI, etc., interfacing with input device 940 (eg, keyboard 140, 400). Operating system 960 may be a MS Or any suitable operating system configured to operate as a platform to directly or indirectly (e.g., by running software of the OS) perform the FKC steps described herein. Device 940 may be any suitable FKC-enabled input device (e.g., keyboard 140, 400), and may communicate with OS 960 via HID reporting or other suitable communication protocol, as will be understood by those of ordinary skill in the art with the benefit of this disclosure.

[0132] At operation 921, user 920 presses "left Shift" on device 940. Device 940 may immediately send a "left Shift" make command to OS 960 via a HID report (operation 941). Then, user 920 presses the "x" key (operation 922), and device 940 sends a HID report with instructions for OS 960 to execute a "left Shift" break command (e.g., pause modifier) ​​and a "left CTRL" make command (operation 942), followed by a "y" make command (operation 943). Then, the user releases the "x" key (operation 923), and device 940 sends instructions for OS 960 to execute a "y" break command and a "left Ctrl" break command (operation 944). Note that when the user presses "x", the device needs to first pause "left Shift" because it has already been sent to the OS (as described above, for latency, reliability, and consistency). When the user releases "x", no interrupt is sent for "Left Shift" because it is still being pressed by the user.

[0133] At the end of the above sequence, if "Left Shift" is still pressed, and the user presses another key, "Left Shift" is unpaused first, because "Left Shift" needs to be applied in the default manner, since the combination of "Left Shift" and the new key is not found in the FKC table 900, so "Left Shift" will now be applied, as detailed in the following sequence:

[0134] At operation 924, the user presses the "z" key while still pressing the "left shift" key from the previous sequence (operations 921 to 944). Then, the device 940 sends the "left shift" enable command (unpause modifier - operation 945) and the "z" enable command (operation 946), thereby instantiating the "left shift + z" command at the OS 960, which is a non-FKC key trigger. When the user releases the "z" key (operation 924), the device 940 sends the "z" interrupt command (operation 947). When the user releases the "left shift" key (operation 926), the device 940 sends the "left shift" interrupt command 948. Note that in response to corresponding instructions from the input device, the modifiers in the OS are suspended and unsuspended at different times to apply FKC-based customization and restore back to non-FKC-based output, as required by the key sequence.

[0135] In the next key sequence, similar to the above sequence, when the user presses "Left Shift" + "x" (FKC trigger), the "Left Shift" modifier is suspended. However, when the user releases "Left Shift", the device 940 does not send a HID report because "Left Shift" has been suspended. Also note that in the following sequence, the target key is released when the corresponding physical trigger key is released.

[0136] At operation 927, the user presses and holds "Left Shift", and the device 940 then sends a "Left Shift" enable command to the OS 960. Then, the user presses the "x" key (operation 928), and the device 940 sends a "Left Shift" interrupt command (pause modifier), a "Left CTRL" enable command (operation 950), and a "y" enable command (operation 951). When the user releases the "Left Shift" key (operation 929), no HID report is sent because "Left Shift" has been paused. At operation 930, the user presses the "z" key, and the device 940 sends a "z" enable command to the OS 960 (operation 952). At operation 931, the user releases the "z" key, and the device 940 sends a "z" interrupt command (operation 953). At operation 932, the user releases the "x" key, and the device 940 sends a "y" interrupt and a "Left Ctrl" interrupt command to the OS 960 (operation 954). Note that the target key gets released when the corresponding physical trigger key is released.

[0137] It should be understood that according to certain embodiments, Fig. 9The specific steps shown in provide a specific method 900 for remapping keys on an FKC-enabled input device. Other sequences of steps may also be performed according to alternative implementations. Furthermore, additional steps may be added or removed depending on the specific application. Any combination of variations may be used, and those of ordinary skill in the art will appreciate many variations, modifications, and alternative implementations thereof with the benefit of this disclosure.

[0138] Fig.10 1 is a simplified flow chart illustrating aspects of a method 1010 for remapping keys on an FKC-enabled input device (e.g., keyboard 140, 400) according to certain embodiments. The method 1010 may be performed by processing logic, which may include hardware (circuitry, dedicated logic, etc.), software operating on appropriate hardware (e.g., a general-purpose computing system or a dedicated machine), firmware (embedded software), or any combination thereof. In certain embodiments, the method 1010 may be performed by a system 200 (e.g., a processor 210 and memory 220 for a device 1040 (e.g., keyboard 140, 400)), a system 300 (e.g., a processor 302 and a memory storage subsystem 306 for a host computing device 110), or a combination thereof.

[0139] Method 1010 shows a flow chart for remapping key triggers to key targets in an FKC-enabled input device. In particular, the flow chart shows a sequence of events for remapping "left Shift" + "w" (key trigger) → "left Shift" + "s" (key target). The FKC table 1000 of the key remapping database includes key trigger 1002 and key target 1004 lookup tables that identify various logical / HID modifier bitmaps, physical keys, corresponding flags and actions, etc., for the FKC-enabled input device to identify the expected trigger / target pair. Referring to method 1010, the user 1020, the device 1040, and the OS 1060 can be respectively similar to Fig. 9 A user 920, a device 940, and an OS 960 are provided.

[0140] At operation 1021, user 1020 presses "Left Shift" on device 1040. Device 1040 may immediately send a "Left Shift" enable command to OS 1060 via a HID report (operation 1041). Then, user 1020 presses the "w" key (operation 1022), and device 1040 sends a HID report with instructions for OS 1060 to execute "s" (operation 1042). Note that "Left Shift" is not paused in this case (unlike method 900) because Left Shift also exists in the target key. At operation 1023, the user releases the "w" key, and device 1040 sends an "s" interrupt command to OS 1060. Note that when the user releases "x", no interrupt is sent to "Left Shift" because it is still being pressed by the user. At operation 1024, the user presses the "z" key, and device 1040 sends a "z" enable command to OS 1060 (operation 1044). In this case, if the "left shift" is still pressed, and the user presses another key, the "left shift" command should be unpaused first. At operation 1025, the user releases the "z" key, and the device 1040 sends the "z" interrupt command to the OS 1060. At operation 1026, the user releases the "left shift" key, and the device 1040 sends the "left shift" interrupt command to the OS 1060.

[0141] At operation 1027, the user presses and holds "Left Shift", and the device 1040 then sends a "Left Shift" enable command (operation 1047). Then, the user presses the "w" key (operation 1028), and the device 1040 sends an "s" enable command to the OS 1060. Note that "Left Shift" is not paused in this case because it also exists in the target. At operation 1029, the user releases the "Left Shift" key, and the device 1040 sends a "Left Shift" interrupt command to the OS 1060. When the user releases "Left Shift", the device 1040 immediately sends a HID interrupt, even if it is not in the target, because in some embodiments, the FKC does not attempt to count the keys so as to send an interrupt command only at the last release. At operation 1030, the user presses the "z" key, and the device 1040 sends a "z" enable command to the OS 1060 (operation 1050). At operation 1031, the user releases the "z" key, and the device 1040 sends a "z" interrupt command to the OS 1060 (operation 1051). At operation 1032, the user releases the "w" key, and the device 1040 sends an "s" interrupt command to the OS 1060 (operation 1052).

[0142] It should be understood that according to certain embodiments, Fig.10The specific steps shown in provide a specific method 1000 for remapping keys on an FKC-enabled input device. Other sequences of steps may also be performed according to alternative implementations. Furthermore, additional steps may be added or removed depending on the specific application. Any combination of variations may be used, and those of ordinary skill in the art will appreciate many variations, modifications, and alternative implementations thereof with the benefit of this disclosure.

[0143] Fig.11 1 is a simplified flow chart illustrating aspects of a method 1110 for remapping keys on an FKC-enabled input device (e.g., keyboard 140, 400) according to certain embodiments. The method 1110 may be performed by processing logic, which may include hardware (circuitry, dedicated logic, etc.), software operating on appropriate hardware (e.g., a general-purpose computing system or a dedicated machine), firmware (embedded software), or any combination thereof. In certain embodiments, the method 1110 may be performed by a system 200 (e.g., a processor 210 and memory 220 for a device 1140 (e.g., keyboard 140, 400)), a system 300 (e.g., a processor 302 and memory storage subsystem 306 for a host computing device 110), or a combination thereof.

[0144] Method 1110 shows a flow chart for remapping key triggers to key targets in an FKC-enabled input device. In particular, the flow chart shows a sequence of events for remapping "left Ctrl" (key trigger) → "left Shift" using logical modifier updates. The FKC table 1100 of the key remapping database includes key trigger 1102 and key target 1104 lookup tables that identify various logical / HID modifier bitmaps, physical keys, corresponding flags and actions, etc., for the FKC-enabled input device to identify the expected trigger / target pair. Referring to method 1110, the user 1120, the device 1140, and the OS 1160 can be respectively similar to Fig. 9 A user 920, a device 940, and an OS 960 are provided.

[0145] At operation 1121, user 1120 presses "left Ctrl" on device 1140. Device 1140 can immediately send a "left Ctrl" enable command to OS 1160 via a HID report (operation 1141). Then, user 1120 presses the "a" key (operation 1122), and device 1140 sends a HID report with an instruction to make OS 1160 perform "a" (operation 1142). At operation 1123, the user releases the "a" key, and device 1140 sends an "a" interrupt command to OS 1160. At operation 1124, the user releases the "left Ctrl" key, and device 1140 sends a "left Shift" interrupt command to OS 1160 (operation 1144). Note that in some embodiments, there is no distinction between uppercase and lowercase characters in the HID scan code, and uppercase is usually determined by OS based on whether the shift key is pressed down. This concept can be applied to any of the examples presented herein. The "Left Shift" enable and the "a" enable applied here are sent, and the OS determines whether an uppercase "A" is to be applied, as will be understood by one of ordinary skill in the art with the benefit of this disclosure.

[0146] At operation 1125, the user 1120 presses the "left Ctrl" key, and the device 1140 sends the "left Shift" key to the OS 1160. At operation 1126, the user 1120 presses the "left Shift" key. At operation 1127, the user releases the "left Ctrl" key, and the device 1140 sends the "left Shift" interrupt to the OS 1160 (operation 1146). At operation 1128, the user releases the "left Shift" key. In this case, when the user releases the "left Ctrl", the device 1140 immediately sends the HID interrupt even if the "left Shift" key is still being pressed, because in some embodiments, the key presses are not counted and the interrupt is only sent at the last release.

[0147] It should be understood that according to certain embodiments, Fig.10 The specific steps shown in provide a specific method 1000 for remapping keys on an FKC-enabled input device. Other sequences of steps may also be performed according to alternative implementations. Furthermore, additional steps may be added or removed depending on the specific application. Any combination of variations may be used, and those of ordinary skill in the art will appreciate many variations, modifications, and alternative implementations thereof with the benefit of this disclosure.

[0148] Fig.121 is a simplified flow chart illustrating aspects of a method 1200 for remapping keys on an FKC-enabled input device (e.g., keyboard 140, 400) according to some embodiments. The method 1200 may be performed by processing logic, which may include hardware (circuitry, dedicated logic, etc.), software operating on appropriate hardware (e.g., a general-purpose computing system or a dedicated machine), firmware (embedded software), or any combination thereof. In some embodiments, the method 1200 may be performed by the system 200 (e.g., processor 210 and memory 220), the system 300, or a combination thereof.

[0149] According to some implementations, at operation 1210 , method 1200 may include receiving (eg, by processor 210 ) a first control signal indicating that a first key on a keyboard is being pressed, the first key being functionally assigned as a logical modifier.

[0150] According to some embodiments, at operation 1220, method 1200 may include: sending, by one or more processors, a first enable command indicating that the (logical) modifier is valid to a host computing device communicatively coupled to the keyboard. In some embodiments, the keyboard communicates with the host computing device via a human interface device (HID) type command.

[0151] According to some implementations, at operation 1230, method 1200 may include receiving, by one or more processors, a second control signal indicating that a second key on the keyboard is being simultaneously pressed, the second key being functionally assigned as a non-modifier alphanumeric character.

[0152] According to some embodiments, at operation 1240, method 1200 may include: accessing, by one or more processors, a key remapping database stored on the keyboard, the key remapping database including key triggers and remapped key targets, each key trigger corresponding to a specific combination of one or more keys of the keyboard, and each corresponding key target corresponding to a different function assignment than a default function assignment for the combination of the one or more keys. In some aspects, the key remapping database is stored as a list-based or bit-field-based database on a memory stored on the keyboard.

[0153] In accordance with certain embodiments, at operation 1250 of method 1200, in response to determining that the combination of the first key and the second key is not included as a key trigger in the key remapping database, a third enable command corresponding to a non-modifier alphanumeric character of the second key is sent to the host computing device by one or more processors while the first key and the second key are pressed (operation 1252).

[0154] According to certain embodiments, at operation 1250 of method 1200, in response to determining that the combination of the first key and the second key is included in the key remapping database as a key trigger: a first interrupt command indicating that a (logical) modifier is invalid is sent to the host computing device by one or more processors while the first key and the second key are pressed; and a second enable command corresponding to a key target associated with the combination of the pressed first key and the second key in the remapping database is sent to the host computing device by one or more processors while the first key and the second key are pressed (operation 1254).

[0155] According to some implementations, at operation 1260, method 1200 may include receiving, by one or more processors, an indication that a second key on the keyboard was released.

[0156] According to some implementations, at operation 1262, method 1200 may include sending, by the one or more processors, to the host computing device a second interrupt command indicating that the target key is terminated.

[0157] According to some embodiments, at operation 1270, method 1200 may include receiving, by one or more processors, a third control signal indicating that a third key on the keyboard is being pressed while the first key is still being pressed.

[0158] According to some implementations, at operation 1272, method 1200 may include accessing, by one or more processors, a key remapping database.

[0159] According to certain embodiments, at operation 1280, in response to determining that the combination of the first key and the third key is not included as a key trigger in the remapping database, method 1200 may include: sending, by one or more processors, a fourth enable command indicating that a (logical) modifier switches from invalid to valid to a host computing device while the first key and the third key are pressed; and sending, by one or more processors, a fifth enable command corresponding to a default function assignment of the third key to the host computing device while the first key and the third key are pressed (operation 1282).

[0160] According to some embodiments, at operation 1280, in response to determining that the combination of the first key and the third key is included in the remapping database as a key trigger, method 1200 may include: sending, by one or more processors, a third enable command corresponding to a key target associated with the combination of the pressed first key and the third key in the remapping database to the host computing device while the first key and the third key are pressed (operation 1284).

[0161] It should be understood that according to certain embodiments, Fig.12The specific steps shown in provide a specific method 1200 for remapping keys on an FKC-enabled input device. Other sequences of steps may also be performed according to alternative implementations. Furthermore, additional steps may be added or removed depending on the specific application. Any combination of variations may be used, and those of ordinary skill in the art will appreciate many variations, modifications, and alternative implementations thereof with the benefit of this disclosure.

[0162] Most embodiments utilize at least one network that supports communications using any of a variety of commercially available protocols familiar to those skilled in the art, such as TCP / IP, UDP, OSI, FTP, UPnP, NFS, CIFS, etc. The network can be, for example, a local area network, a wide area network, a virtual private network, the Internet, an intranet, an extranet, a public switched telephone network, an infrared network, a wireless network, and any combination thereof.

[0163] In embodiments utilizing a web server as an operational server or security server, the web server may run any of a variety of server or middle-tier applications, including HTTP servers, FTP servers, CGI servers, data servers, Java servers, and business application servers. The server may also be capable of executing programs or scripts in response to requests from user devices, such as by executing one or more applications that may be implemented as one or more scripts or programs written in any programming language or any scripting language and combinations thereof, including but not limited to C, C# or C++, scripting languages ​​such as Perl, Python or TCL. The server may also include a database server, including but not limited to and Commercially available database server.

[0164] Such a device may also include a computer-readable storage medium reader, a communication device (e.g., a modem, (wireless or wired) network card, an infrared communication device, etc.) and a working memory as described above. A computer-readable storage medium reader may be connected to a non-transient computer-readable storage medium or configured to receive a non-transient computer-readable storage medium, thereby representing a remote, local, fixed and / or removable storage device and a storage medium for temporarily and / or more permanently containing, storing, transmitting and retrieving computer-readable information. The system and various devices will also typically include many software applications, modules, services or other elements located in at least one working memory device, including an operating system and an application program, such as a client application or a browser. It should be understood that alternative implementations may have many variations based on the above-described implementations. For example, customized hardware may also be used and / or specific elements may be implemented with hardware, software (including portable software, such as a small application program) or both. In addition, connections to other computing devices such as network input / output devices may be employed.

[0165] Many specific details are set forth herein to provide a thorough understanding of the claimed subject matter. However, it will be appreciated by those skilled in the art that the claimed subject matter can be practiced without these specific details. In other instances, methods, devices, or systems known to those of ordinary skill are not described in detail to avoid blurring the claimed subject matter. The various embodiments shown and described are provided only as examples to illustrate the various features of the claims. However, the features shown and described with respect to any given embodiment are not necessarily limited to the associated embodiments, and can be used or combined with other embodiments shown and described. In addition, the claims are not intended to be limited to any one example embodiment.

[0166] Although the subject matter has been described in detail with respect to specific embodiments of the invention, it will be understood that those skilled in the art can easily generate changes, modifications and equivalents to such embodiments after obtaining an understanding of the foregoing. Therefore, it should be understood that it will be readily apparent to those of ordinary skill in the art that the present disclosure is presented for purposes of illustration and not limitation, and does not exclude the inclusion of such modifications, modifications and / or additions to the subject matter. In fact, the methods and systems described herein may be implemented in various other forms; in addition, various omissions, substitutions and changes may be made to the form of the methods and systems described herein without departing from the spirit of the present disclosure. The attached claims and their equivalents are intended to cover such forms or modifications as would fall within the scope and spirit of the present disclosure.

[0167] Although the present disclosure provides certain example embodiments and applications, it is obvious to those skilled in the art that other embodiments, including embodiments that do not provide all of the features and advantages set forth herein, are also within the scope of the present disclosure. Therefore, the scope of the present disclosure is intended to be limited only by reference to the appended claims.

[0168] Unless expressly stated otherwise, it should be understood that throughout this specification, discussions utilizing terms such as "processing," "computing," "calculating," "determining," and "identifying" refer to the actions or processes of a computing device, such as one or more computers or similar electronic computing devices, that manipulates or transforms data represented as physical electronic or magnetic quantities within a memory, register, or other information storage device, transmission device, or display device of a computing platform.

[0169] One or more systems discussed herein are not limited to any particular hardware architecture or configuration. A computing device may include any suitable arrangement of components that provide a result conditioned on one or more inputs. Suitable computing devices include multi-function microprocessor-based computer systems that access stored software that programs or configures a computing system from a general-purpose computing device to a dedicated computing device that implements one or more embodiments of the present subject matter. Any suitable programming, scripting, or other type of language or combination of languages ​​may be used to implement the teachings contained herein in software for programming or configuring a computing device.

[0170] Implementations of the methods disclosed herein may be performed in the operation of such a computing device. The order of the blocks presented in the above examples may be changed—for example, the blocks may be reordered, combined, and / or divided into sub-blocks. Certain blocks or processes may be performed in parallel.

[0171] Unless otherwise specifically stated or understood otherwise in the context of use, conditional language used herein, such as "can," "may," "could," "may," "for example," and the like, is generally intended to convey that certain examples include certain features, elements, and / or steps while other examples do not. Thus, such conditional language is generally not intended to imply that one or more examples in any way require features, elements, and / or steps, or that one or more examples must include logic for determining, with or without author input or prompting, whether such features, elements, and / or steps are included in any particular example or are to be performed in any particular example.

[0172] The terms "comprise", "include", "have", etc. are synonyms and are used inclusively in an open manner, and do not exclude additional elements, features, actions, operations, etc. In addition, the term "or" is used in its inclusive sense (rather than in its exclusive sense), so that, for example, when the term "or" is used to connect a list of elements, it means one, some or all of the elements in the list. The use of "suitable for" or "configured to" herein means open and inclusive language, which does not exclude the device that is suitable for or configured to perform additional tasks or steps. Additionally, the use of "based on" means open and inclusive, because the process, step, calculation or other action "based on" one or more of the conditions or values ​​may actually be based on additional conditions or values ​​other than those described. Similarly, the use of "based at least in part" means open and inclusive, because the process, step, calculation or other action "based at least in part" on one or more of the conditions or values ​​may actually be based on additional conditions or values ​​other than those described. The titles, lists and numbers included herein are only for ease of explanation and are not meant to be limited.

[0173] The various features and processes described above can be used independently of each other, or can be used in combination in various ways. All possible combinations and sub-combinations are intended to fall within the scope of the present disclosure. In addition, in some embodiments, certain methods or processing blocks can be omitted. The methods and processes described herein are also not limited to any specific sequence, and the blocks or states related thereto can be performed in other appropriate sequences. For example, the described blocks or states can be performed in a sequence other than the sequence specifically disclosed, or multiple blocks or states can be combined in a single block or state. Example blocks or states can be performed serially, in parallel, or in some other ways. Blocks or states can be added to the disclosed examples or removed from the disclosed examples. Similarly, the example systems and components described herein can be configured differently from those described. For example, compared with the disclosed examples, elements can be added, removed, or rearranged.

Claims

1. A method comprising: receiving, by one or more processors of a keyboard, a first control signal indicating that a first key on the keyboard is being pressed, the first key being functionally assigned as a modifier; sending, by the one or more processors, a first enable command to a host computing device communicatively coupled to the keyboard indicating that the modifier is valid; receiving, by the one or more processors, a second control signal indicating that a second key on the keyboard is being simultaneously pressed, the second key being functionally assigned as a non-modifier alphanumeric character; accessing, by the one or more processors, a key remapping database stored on the keyboard, the key remapping database comprising key triggers and remapped key targets, each key trigger corresponding to a particular combination of one or more keys of the keyboard, and each corresponding key target corresponding to a different function assignment than a default function assignment for the combination of the one or more keys; and In response to determining that a combination of the first key and the second key is included as a key trigger in the key remapping database: while the first key and the second key are pressed, sending, by the one or more processors, to the host computing device a first interrupt command indicating that the modifier is invalid; as well as While the first key and the second key are pressed, a second enable command corresponding to a key target of the remapping database associated with the pressed combination of the first key and the second key is sent by the one or more processors to the host computing device.

2. The method according to claim 1, further comprising: In response to determining that the combination of the first key and the second key is not included as a key trigger in the key remapping database: A third enable command corresponding to the non-modifier alphanumeric character of the second key is sent by the one or more processors to the host computing device while the first key and the second key are pressed.

3. The method according to claim 1, further comprising: receiving, by the one or more processors, an indication that the second key on the keyboard was released; as well as A second interrupt command is sent, by the one or more processors, to the host computing device indicating that the target key is terminated.

4. The method according to claim 3, further comprising: receiving, by the one or more processors, a third control signal indicating that a third key on the keyboard is being pressed while the first key is still being pressed; accessing, by the one or more processors, the key remapping database; as well as In response to determining that a combination of the first key and the third key is included as a key trigger in the remapping database: While the first key and the third key are pressed, a third enable command corresponding to a key target of the remapping database associated with the pressed combination of the first key and the third key is sent by the one or more processors to the host computing device.

5. The method according to claim 4, further comprising: In response to determining that the combination of the first key and the third key is not included as a key trigger in the remapping database: while the first key and the third key are pressed, sending, by the one or more processors, to the host computing device a fourth enable command instructing the modifier to switch from invalid to valid; as well as While the first key and the third key are pressed, a fifth enable command corresponding to a default function assignment of the third key is sent by the one or more processors to the host computing device.

6. The method according to claim 5, further comprising: receiving, by the one or more processors, an indication that the third key on the keyboard was released; sending, by the one or more processors, to the host computing device a third interrupt command indicating that the default function assignment of the third key is terminated; receiving, by the one or more processors, an indication that the first key on the keyboard was released; as well as A fourth interrupt command is sent, by the one or more processors, to the host computing device indicating that the modifier is released.

7. The method according to claim 1, wherein: The key target includes a combination of multiple function assignments.

8. The method according to claim 1, wherein: The key remapping database is stored as a list-based or bit-field-based database on a memory stored on the keyboard.

9. The method according to claim 1, wherein: The keyboard communicates with the host computing device via human interface device (HID) type commands.

10. A keyboard comprising: one or more processors; One or more non-transitory computer-readable storage media containing instructions configured to cause the one or more processors to perform operations comprising: receiving, by the one or more processors of the keyboard, a first control signal indicating that a first key on the keyboard is being pressed, the first key being functionally assigned as a modifier; sending, by the one or more processors, a first enable command to a host computing device communicatively coupled to the keyboard indicating that the modifier is valid; receiving, by the one or more processors, a second control signal indicating that a second key on the keyboard is being simultaneously pressed, the second key being functionally assigned as a non-modifier alphanumeric character; accessing, by the one or more processors, a key remapping database stored on the keyboard, the key remapping database comprising key triggers and remapped key targets, each key trigger corresponding to a particular combination of one or more keys of the keyboard, and each corresponding key target corresponding to a different function assignment than a default function assignment for the combination of the one or more keys; and In response to determining that a combination of the first key and the second key is included as a key trigger in the key remapping database: While the first key and the second key are being pressed, sending, by the one or more processors, a first interrupt command to the host computing device indicating that the modifier is invalid; and While the first key and the second key are pressed, a second enable command corresponding to a key target of the remapping database associated with the pressed combination of the first key and the second key is sent by the one or more processors to the host computing device.

11. The keyboard according to claim 10, wherein: The instructions are further configured to cause the one or more processors to perform operations comprising: In response to determining that the combination of the first key and the second key is not included as a key trigger in the key remapping database: A third enable command corresponding to the non-modifier alphanumeric character of the second key is sent by the one or more processors to the host computing device while the first key and the second key are pressed.

12. The keyboard according to claim 10, wherein: The instructions are further configured to cause the one or more processors to perform operations comprising: receiving, by the one or more processors, an indication that the second key on the keyboard was released; and A second interrupt command is sent, by the one or more processors, to the host computing device indicating that the target key is terminated.

13. The keyboard according to claim 12, wherein: The instructions are further configured to cause the one or more processors to perform operations comprising: receiving, by the one or more processors, a third control signal indicating that a third key on the keyboard is being pressed while the first key is still being pressed; accessing, by the one or more processors, the key remapping database; and In response to determining that a combination of the first key and the third key is included as a key trigger in the remapping database: While the first key and the third key are pressed, a third enable command corresponding to a key target of the remapping database associated with the pressed combination of the first key and the third key is sent by the one or more processors to the host computing device.

14. The keyboard according to claim 13, wherein: The instructions are further configured to cause the one or more processors to perform operations comprising: In response to determining that the combination of the first key and the third key is not included as a key trigger in the remapping database: While the first key and the third key are being pressed, sending, by the one or more processors, to the host computing device a fourth enable command instructing the modifier to switch from invalid to valid; and While the first key and the third key are pressed, a fifth enable command corresponding to a default function assignment of the third key is sent by the one or more processors to the host computing device.

15. The keyboard according to claim 14, wherein: The instructions are further configured to cause the one or more processors to perform operations comprising: receiving, by the one or more processors, an indication that the third key on the keyboard was released; sending, by the one or more processors, to the host computing device a third interrupt command indicating that the default function assignment of the third key is terminated; receiving, by the one or more processors, an indication that the first key on the keyboard was released; and A fourth interrupt command is sent, by the one or more processors, to the host computing device indicating that the modifier is released.

16. A non-transitory computer program product tangibly embodied in a machine-readable non-transitory storage medium, the machine-readable non-transitory storage medium comprising instructions configured to cause one or more processors to perform operations comprising: receiving, by the one or more processors of a keyboard, a first control signal indicating that a first key on the keyboard is being pressed, the first key being functionally assigned as a modifier; sending, by the one or more processors, a first enable command to a host computing device communicatively coupled to the keyboard indicating that the modifier is valid; receiving, by the one or more processors, a second control signal indicating that a second key on the keyboard is being simultaneously pressed, the second key being functionally assigned as a non-modifier alphanumeric character; accessing, by the one or more processors, a key remapping database stored on the keyboard, the key remapping database comprising key triggers and remapped key targets, each key trigger corresponding to a particular combination of one or more keys of the keyboard, and each corresponding key target corresponding to a different function assignment than a default function assignment for the combination of the one or more keys; and In response to determining that a combination of the first key and the second key is included as a key trigger in the key remapping database: while the first key and the second key are pressed, sending, by the one or more processors, to the host computing device a first interrupt command indicating that the modifier is invalid; as well as While the first key and the second key are pressed, a second enable command corresponding to a key target of the remapping database associated with the pressed combination of the first key and the second key is sent by the one or more processors to the host computing device.

17. The non-transitory computer program product of claim 16, wherein: The instructions also cause one or more processors to perform operations including: In response to determining that the combination of the first key and the second key is not included as a key trigger in the key remapping database: A third enable command corresponding to the non-modifier alphanumeric character of the second key is sent by the one or more processors to the host computing device while the first key and the second key are pressed.

18. The non-transitory computer program product of claim 16, wherein: The instructions also cause one or more processors to perform operations including: receiving, by the one or more processors, an indication that the second key on the keyboard was released; and A second interrupt command is sent, by the one or more processors, to the host computing device indicating that the target key is terminated.

19. The non-transitory computer program product of claim 18, wherein: The instructions are further configured to cause the one or more processors to perform operations comprising: receiving, by the one or more processors, a third control signal indicating that a third key on the keyboard is being pressed while the first key is still being pressed; accessing, by the one or more processors, the key remapping database; and In response to determining that a combination of the first key and the third key is included as a key trigger in the remapping database: While the first key and the third key are pressed, a third enable command corresponding to a key target of the remapping database associated with the pressed combination of the first key and the third key is sent by the one or more processors to the host computing device.

20. The non-transitory computer program product of claim 19, wherein: The instructions are further configured to cause the one or more processors to perform operations comprising: In response to determining that the combination of the first key and the third key is not included as a key trigger in the remapping database: While the first key and the third key are being pressed, sending, by the one or more processors, to the host computing device a fourth enable command instructing the modifier to switch from invalid to valid; and While the first key and the third key are pressed, a fifth enable command corresponding to a default function assignment of the third key is sent by the one or more processors to the host computing device.

Images