Full key customization on input device

Abstract

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

Description

Technical Field

[0001] This disclosure relates to input devices. Background Technology

[0002] Input devices such as keyboards or key-based computer peripherals remain a popular and effective user interface between humans and computers. Over the years, keyboards have evolved and improved in terms of quality, functionality, ergonomics, and lifespan. Modern keyboards typically include a numeric keypad, function keys, media keys, and numerous other key functions in any number of different configurations. Although many configurations and options are available to consumers, keyboards are often locked into a specific key layout and corresponding functions. Therefore, users may resort to purchasing multiple keyboard devices to better suit specific applications, which can be expensive and wasteful. A better solution is needed. Summary of the Invention

[0003] In some implementations, a method includes: receiving, by 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 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 one or more processors, a second control signal indicating that a second key on the keyboard is being pressed simultaneously, the second key being functionally assigned as an alphanumeric character without a modifier; and 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 on the keyboard, and each corresponding key target corresponding to a different function assignment compared to a default function assignment for the combination of one or more keys. In some embodiments, 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, the method includes: simultaneously with the pressing of the first key and the second key, sending a first interrupt command indicating that a modifier is invalid to a host computing device by one or more processors; and simultaneously with the pressing of the first key and the second key, sending a second enable command to the host computing device corresponding to a key target in 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 in the key remapping database as a key trigger, the method includes: simultaneously with the pressing of the first key and the second key, sending a third enable command to the host computing device corresponding to an alphanumeric character of the second key without a modifier.

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

[0005] In some embodiments, a keyboard includes: 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 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 pressed simultaneously, the second key being functionally assigned as an alphanumeric character without 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 on the keyboard, and each corresponding key target corresponding to a different function assignment compared to a default function assignment for the combination of 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: simultaneously, one or more processors sending a first interrupt command to a host computing device indicating that a modifier is invalid; and simultaneously, simultaneously, one or more processors sending a second enable command to the host computing device corresponding to a key target in the remapping database associated with the pressed combination of the first and second keys. In some cases, the instructions are further configured to cause one or more processors to perform an operation including: in response to determining that a combination of the first key and a second key is not included as a key trigger in the key remapping database: simultaneously, one or more processors sending a third enable command to the host computing device corresponding to an alphanumeric character of the second key without a modifier.

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

[0007] In some embodiments, a non-transitory computer program product is tangibly implemented 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 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 one or more processors, a second control signal indicating that a second key on the keyboard is being pressed simultaneously, the second key being functionally assigned as an alphanumeric character without a modifier; and accessing, by one or more processors, stored in... A key remapping database on a keyboard, comprising key triggers and remapped key targets, each key trigger corresponding to a specific combination of one or more keys on the keyboard, and each corresponding key target corresponding to a different function assignment compared to the default function assignment for the combination of one or more keys; in response to determining that a combination of a first key and a second key is included in the key remapping database as a key trigger: simultaneously with the pressing of the first key and the second key, a first interrupt command indicating that a modifier is invalid is sent to a host computing device by one or more processors; and simultaneously with the pressing of the first key and the second key, a second enable command corresponding to the key target in the remapping database associated with the pressed combination of the first key and the second key is sent to the host computing device by one or more processors.

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

[0009] The terms and expressions used are used descriptively and not restrictively, and are not intended to exclude any equivalent forms of the features shown and described or any part thereof. However, it is recognized that various modifications are possible within the scope of the claimed systems and methods. Therefore, it should be understood that although the systems and methods have been specifically disclosed by way of example and optional features, those skilled in the art will recognize modifications and variations to the concepts disclosed herein, and such modifications and variations are considered to be within the scope of the systems and methods as defined by the appended claims.

[0010] This invention is not intended to identify key or essential features of the claimed subject matter, nor is it intended to be used alone to define the scope of the claimed subject matter. The subject matter should be understood by referring to the appropriate portions of the entire specification, any or all of the accompanying drawings, and each claim.

[0011] The foregoing, as well as other features and examples, will be described in more detail below in the specification, claims and drawings. Attached Figure Description

[0012] The features of the various embodiments of the present invention described above, 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, which may include any of a variety of host computing devices and computer peripherals, including computer peripherals that can be configured to perform aspects of the various inventive concepts described herein.

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

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

[0016] Figure 4 An example of the base layer, FN layer, and GShift layer in an input device utilizing an FKC system according to certain embodiments is shown;

[0017] Figure 5 and Figure 6 The logical results of certain key press combinations on a keyboard according to some embodiments are shown;

[0018] Figure 7 This is a simplified flowchart illustrating various aspects of a method for FKC trigger matching according to certain embodiments;

[0019] Figure 8 A lookup table for multiple layers in an input device for FKC enabling, according to certain embodiments, is shown;

[0020] Figure 9 This is a simplified flowchart illustrating various aspects of a method for remapping keys on an FKC-enabled input device according to certain embodiments.

[0021] Figure 10 This is a simplified flowchart illustrating various aspects of a method for remapping keys on an FKC-enabled input device according to certain embodiments.

[0022] Figure 11 This is a simplified flowchart illustrating aspects of a method for remapping keys on an FKC-enabled input device according to certain embodiments; and

[0023] Figure 12 This is a simplified flowchart illustrating various aspects of a method for remapping keys on an FKC-enabled input device according to certain embodiments.

[0024] Throughout the accompanying drawings, it should be noted that the same reference numerals are generally used to depict the same or similar elements, features, and structures. Detailed Implementation

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

[0026] In the following description, various examples of programmable input devices are described. Specific configurations and details are set forth for illustrative purposes to provide a thorough understanding of the implementations. However, it will be apparent to those skilled in the art that certain implementations can be practiced or implemented without every detail disclosed. Furthermore, well-known features may be omitted or simplified to prevent any confusion regarding 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. Aspects of the invention relate to input devices with onboard systems (e.g., firmware) to enable fully customizable keys, buttons, and shortcuts, made possible by assigning new target behaviors to specific trigger keys. Further 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), resulting in improved latency, accuracy, reliability, and consistency, thereby contributing to an improved user experience (UX). Software-based (SW) FKC systems, as found in some conventional devices, typically exhibit poor latency and consistency. For example, in SW-based FKC systems, the total time from a user key press to the corresponding device report delivery to the host computing device's operating system (OS) can range from tens to hundreds of milliseconds. Such latency may be negligible for some applications such as audio volume control, but can be catastrophic in certain gaming scenarios (e.g., FPS, driving simulators, etc.) and is therefore intolerable for modern consumers. Another issue with SW-based FKC systems is their behavior during system startup or wake-up from sleep mode. Users typically must enter a password before gaining access to the OS. At this time, because the OS and corresponding software haven't yet established an FKC remapping, the input device will usually be in its default operating mode. Therefore, if a password key sequence is generated on an FKC system using a key remapped to different target values, the same key sequence will produce different outputs at startup, causing password attempts to fail. In contrast, the novel implementation described herein is based on a local firmware system that exhibits virtually no latency (e.g., <500 μs) between wake-up / startup and the FKC implementation, resulting in immediate FKC access while still adapting to modern device reporting rates (e.g., 1 ms), thus 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 aforementioned issues and other FKC implementation challenges, including the logic for managing FKC-based key combination triggering, modifier handling, key combination press / release events, modifier handling when linking key combinations, modifier suppression and re-enabling, conflicts, parallel key presses, etc., which will be described in detail below.

[0029] It should be understood that this highly detailed overview is presented to provide the reader with a basic understanding of some of the novel aspects of this disclosure, as well as a roadmap for the subsequent details. This highly detailed overview is in no way intended to limit the scope of the various embodiments described throughout the detailed description, and each of the figures cited above is further described below in more detail and to the extent appropriate.

[0030] definition

[0031] Full Key Customization (FKC) This feature allows users to customize the actions of one or more keys, buttons, rotary devices, etc., on an input device (e.g., a keyboard), such as remapping one key to another or programming a key as a playback 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 allows customization of modifier + key combinations, such as assigning custom behavior to Ctrl+x, Shift+Ctrl+y, Fn+z, Fn+Ctrl+x, etc.

[0032] Key: This refers to the physical keys or buttons on an input device (such as a keyboard).

[0033] Modifier The modifier key is defined as any of the following functions: Left Shift, Right Shift, Left Ctrl, Right Ctrl, Left Alt, Right Alt, Left GUI (e.g., the Windows key), Right GUI (e.g., the context menu key), and keyboard keys, but some implementations may specify other modifier keys. In some respects, the left and right modifier keys may be indistinguishable and may be considered equivalent by the host system (and by the user). For example, the shortcut key may typically be assigned as "Ctrl+C," and will work equivalently regardless of whether the left or right Ctrl key is used. However, for certain key combination customizations, some implementations may distinguish between the left and right modifier keys.

[0034] Logical modifiers: FKC allows users to remap any physical key (or key combination) to a modifier key. For example, a user can remap "(physical) X" -> "(logical) Left Shift" or "(physical) Left Ctrl" -> "(logical) Right Alt". This remapping assignment is called a "logical" modifier, not a physical modifier key, and is mapped to its corresponding logical modifier by default. Logical modifier values ​​can take into account both the pressed state of uncustomized physical modifier keys and the pressed state of keys remapped to modifiers via FKC. Logical modifiers are values ​​internally maintained in FW for matching key triggers.

[0035] Keyboard shortcutsAlso known as "shortcut keys" or "hotkeys," these are key combinations commonly used in modern operating systems and applications, and typically involve pressing and holding one or more modifier keys, and then pressing a single non-modifier key to produce a specific output. Some common examples of key combinations include "Ctrl" + "C" = copy, and "Ctrl" + "Alt" + "Delete" = restart or open Task Manager. For FKC purposes, the key combinations are further defined in a broader context in the implementation described below.

[0036] Trigger (key / combination key) A single control key or shortcut key that is assigned to a custom behavior when pressed. Custom keys or key combinations are also known as "trigger" keys.

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

[0038] Remapping The target behavior differs from the default key output of a single key or key combination.

[0039] Macros: These are a series of variable-length keystrokes or consumer codes that represent the target behavior. Macros can also include delays and other behaviors.

[0040] G key The G key, marked with "G1", "G2", etc., is a custom-configured key. The "G key" is... It has certain characteristics, but can include any customizable key.

[0041] System Environment

[0042] Figure 1 An example of a computer system 100 is shown, which may include any of a variety of host computing devices and computer peripherals, including peripherals (e.g., computer mouse, keyboard, 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 may be coupled to and / or integrated with the host computing device, including a display device 120, a computer mouse 130, a keyboard 140, and may include any other suitable computer peripherals (e.g., microphone, speaker, docking station, headphones, etc.). Each computer peripheral 120 to 140 may 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 (“HMDs”), or any other suitable host computing device (e.g., smartphones, smart wearable devices, etc.). In some cases, multiple host computing devices may be used, and one or more computer peripherals may be communicatively coupled to one or more 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 of the host computing device to control aspects of the host computing device, for example, via one or more computer peripherals.

[0044] Typical computer peripherals can include any suitable input, output, or input / output device, including devices shown (e.g., a computer mouse) and devices not shown (e.g., a remote control, wearable device (e.g., a glove, a watch, a head-mounted display), AR / VR controller, CAD controller, joystick, analog shifter, stylus device, or other suitable devices that can, for example, convert analog input into digital signals for computer processing). By way of example, a computer peripheral (e.g., computer mouse 130) can be configured to provide motion tracking (e.g., x-axis on a plane). The computer peripheral device may provide any of the following features: control signals for y-movement, three-dimensional “air” movement, touch and / or gesture detection, lift detection, orientation detection (e.g., in a 3-DOF system, 6DOF system, etc.), power management functions, input detection (e.g., buttons, scroll wheels, etc.), output functions (e.g., LED control, haptic feedback, etc.), or a number of other features as will be understood by one of ordinary skill in the art. The buttons of the computer mouse 130 and the keys of the keyboard 140 (or any other depressable element on any input device) may include fully customized aspects 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 embodiments described herein generally relate 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 adapted to utilize the novel embodiments described and envisioned herein.

[0046] Systems for operating computer peripherals

[0047] Figure 2 A system 200 for operating a computer peripheral device (e.g., computer mouse 130, keyboard 140, etc.) according to certain embodiments is illustrated. 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 this disclosure. 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 system blocks 220 to 260 can communicate electronically with processor 210 (e.g., via a bus system). System 200 may include additional functional blocks, not shown or discussed to avoid obscuring novel features described herein. System blocks 220 to 260 (also referred to as “modules,” “system,” or “system blocks”) may be implemented as separate modules, or alternatively, more than one system block may be implemented in a single module. As those skilled in the art will understand from this disclosure, in the context described herein, system 200 may be included in any computer peripheral device described or mentioned herein and may also be configured with at least the following regarding… Figures 4 to 12 The description refers to any of the full-key customization implementations presented in this article.

[0048] In some implementations, processor 210 may include one or more microprocessors and may be configured to control the operation of system 200. Alternatively or additionally, processor 210 may include one or more microcontrollers (MCUs), digital signal processors (DSPs), etc., having supporting hardware and / or firmware (e.g., memory, programmable I / O, etc.) and / or software, as will be understood by those skilled in the art. Processor 210 may control some or all aspects of the operation of computer peripherals 140 (e.g., system blocks 220 to 260). Alternatively or additionally, some system blocks 220 to 260 may include additional dedicated processors that can work in conjunction with processor 210. For example, MCUs, μCs, DSPs, etc., may be configured in other system blocks of system 200. Communication block 240 may include a local processor, for example, to control aspects of communication with 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 peripheral devices (e.g., included therein), external to peripheral devices (e.g., off-board processing via a corresponding host computing device), or a combination thereof. Processor 210 may cooperate with any other system block in system 200 to perform the various functions and methods described and / or covered by this disclosure (e.g., Figures 4 to 12 Any one of the following: the "device" action or method (900 to 1200). In some implementations, Figure 3 The processor 302 may 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 may enable increased performance characteristics (e.g., speed and bandwidth) in system 200; however, multiple processors are not necessary and are not necessarily closely related to the novelty of the embodiments described herein. Many variations, modifications, and alternative implementations will be understood by those skilled in the art.

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

[0050] In some embodiments, memory 220 may store various types of data throughout the present disclosure. For example, memory 220 may store and / or include instructions configured to perform the various FKC control schemes presented herein. Memory 220 may be used to store any suitable data to perform any functions described herein and as will be understood by those skilled in the art who benefit from the present disclosure. 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 processor 210). It should be understood that “software” can refer to a sequence of instructions that, when executed by a processing unit (e.g., processor, processing device, etc.), causes system 200 to perform certain operations of a software program. The instructions may be stored as firmware residing in read-only memory (ROM) and / or as an application stored in a media storage device that may be read into memory for processing by the processing device. Software may be implemented as a single program or a collection of single programs and may be stored in a non-volatile storage device and copied wholly or partially to volatile working memory during program execution. The processing device can retrieve program instructions to be executed from the storage subsystem to perform various operations as described herein (e.g., 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 for the battery (not shown), and power management devices (e.g., a voltage regulator—not shown), as well as a power grid within system 200 for providing power to each subsystem (e.g., communication block 240, etc.). In some embodiments, the functionality provided by the power management system 230 may be incorporated into processor 210. Alternatively, some embodiments may not include a dedicated power management block. For example, functional aspects of power management block 240 may be included in or combined with another block (e.g., processor 210). The power source may be a replaceable battery, a rechargeable energy storage device (e.g., a supercapacitor, lithium polymer battery, NiMH, NiCd), a wired power supply, or other suitable power source. The recharging system may be an additional cable (dedicated to recharging purposes), or the recharging system may use a USB connection to recharge the battery.

[0052] According to some embodiments, the communication system 240 can 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 can 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 technologies for communicating with other computing devices and / or peripherals. 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 common types of cables, to enable bidirectional electronic communication with a corresponding host computing device or other external device. Some implementations 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 described herein (e.g., input detection module 250, output control module 260, etc.). 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, reports may be generated solely 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 in any suitable frequency band (e.g., 2.4 GHz). Those skilled in the art will benefit from this disclosure and will understand many modifications, variations, and alternative implementations of this disclosure.

[0053] Input detection module 250 can control the detection of user interactions with input elements (also referred to as "elements") on the input device. For example, as those skilled in the art will understand from this disclosure, input detection module 250 can detect user input from: keys or buttons (e.g., depressable elements), scroll wheels, motion sensors, scroll wheels, trackballs, touchpads (e.g., one-dimensional and / or two-dimensional touch-sensitive touchpads), click wheels, dial pads, keypads, microphones, GUIs, touch-sensitive GUIs, proximity sensors (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 input detection module 250 may be included in or combined with processor 210.

[0054] In some embodiments, the input detection module 250 can detect touches or touch gestures on one or more touch-sensitive surfaces on the input device 130. The input detection module 250 may include one or more touch-sensitive surfaces or touch sensors. Touch sensors typically include sensing elements adapted to detect signals such as direct contact, electromagnetic or electrostatic fields, or beams of electromagnetic radiation. Touch sensors can typically detect changes in received signals, the presence of a signal, or the absence of a signal. Touch sensors may include a source for emitting the detected signal, or the signal may be generated by a secondary source. Touch sensors may be configured to detect the presence of an object at a distance from a reference area or point (e.g., <5 mm), the presence of an object in contact with the reference area or point, or a combination thereof. Some embodiments of the computer peripheral device 150 may or may not utilize touch detection or touch sensing capabilities.

[0055] Input detection block 250 may include touch and / or proximity sensing capabilities. Some examples of touch / proximity sensor types may include, but are not limited to, resistive sensors (e.g., based on standard air-gap 4-wire, based on pressure-dependent (FSR), interpolated FSR, strain gauges, etc., with different electrical properties on carbon-supported plastics), capacitive sensors (e.g., surface capacitance, self-capacitance, mutual capacitance, etc.), optical sensors (e.g., light barrier type (default open or closed), infrared light barrier matrix, laser-based diodes coupled to a photodetector that can measure the time of flight of the optical path, etc.), acoustic sensors (e.g., piezoelectric buzzers coupled to a microphone to detect modified wave propagation patterns associated with the touch point, 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 peripherals. For example, the output control module 260 can control multiple visual output elements (e.g., LEDs, LCD screens), displays, audio outputs (e.g., speakers), haptic output systems, etc. Those skilled in the art will appreciate many modifications, variations, and alternative embodiments of this disclosure.

[0057] As will be understood by those skilled in the art, although certain systems may not be explicitly discussed, they should be considered as part of system 200. For example, system 200 may include a bus system for transmitting 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. Furthermore, while 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. Moreover, blocks do not need to correspond to physically different parts. Blocks may be configured to perform various operations, for example, by programming a processor or providing an appropriate control circuitry system, and depending on how the initial configuration is obtained, various blocks may or may not be reconfigurable.

[0058] Embodiments of the invention can be implemented in a variety of devices, including electronic devices (e.g., computer peripherals) implemented using any combination of circuit systems and software. Furthermore, aspects and / or portions of system 200 may be combined with or operated by other subsystems as needed by design. For example, input detection block 250 and / or memory 220 may operate within processor 210 rather than as separate entities. Additionally, the inventive concepts described herein can be applied to any electronic device. Furthermore, system 200 can be applied to any of the computer peripherals described in the embodiments herein, whether explicitly, implicitly, or by way of default (e.g., those known to those skilled in the art to be applicable to particular computer peripherals). The foregoing embodiments are not intended to be limiting, and those skilled in the art will appreciate numerous applications and possibilities based on this disclosure.

[0059] Systems for operating mainframe computing devices

[0060] Figure 3 This 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 aforementioned functions, behaviors, and / or capabilities that utilize electronic storage or processing, as well as other functions, behaviors, or capabilities 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) 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, smartphone, 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 MCU, microprocessor, application-specific integrated circuit (ASIC), digital signal processor (DSP), digital signal processing device (DSPD), programmable logic device (PLD), field-programmable gate array (FPGA), processor, controller, microcontroller, microprocessor, or electronic unit designed to perform a combination of functions or methods described throughout this disclosure.

[0062] Storage subsystem 306 may be implemented using local storage and / or removable storage media, such as disks, flash memory (e.g., a Secure Digital Card, a Universal Serial Bus flash drive), or any other non-transitory storage media or combination of media. Storage subsystem 306 may include volatile and / or non-volatile storage media. Local storage may include memory subsystem 308, which includes random access memory (RAM) 318 such as dynamic RAM (DRAM), static RAM (SRAM), synchronous dynamic RAM (e.g., DDR), or backup battery RAM, or read-only memory (ROM) 320, or a file storage subsystem 310 that may include one or more code modules. In some embodiments, storage subsystem 306 may store one or more application and / or operating system programs to be executed by processing subsystem 302, including programs that will be executed using a computer to implement some or all of the operations described above. For example, storage subsystem 306 may store one or more code modules for implementing one or more method steps described herein.

[0063] Firmware and / or software implementations can be implemented using modules (e.g., procedures, functions, etc.). Machine-readable media that tangibly implements instructions can be used in implementing the methods described herein. Code modules (e.g., instructions stored in memory) can be implemented within or outside the 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 memory is stored.

[0064] Furthermore, the terms "storage medium" or "storage device" can refer to one or more memories used for storing data, including read-only memory (ROM), RAM, magnetic RAM, magnetic core memory, disk storage media, optical storage media, flash memory devices, and / or other machine-readable media used 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] Furthermore, implementations can be carried out using hardware, software, scripting languages, firmware, middleware, microcode, hardware description languages, and / or any combination thereof. When implemented in software, firmware, middleware, scripting languages, and / or microcode, program code or code segments 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 processes, functions, subroutines, programs, routines, subroutines, modules, software packages, scripts, classes, or combinations of instructions, data structures, and / or program statements. Code segments can be coupled to another code segment or hardware circuitry by passing and / or receiving information, data, arguments, parameters, and / or memory contents. Information, arguments, parameters, data, etc., can be passed, forwarded, or transmitted by appropriate means—including memory sharing, messaging, token passing, network transmission, etc. These descriptions of software, firmware, storage media, etc., apply to systems 200 and 300 and any other implementations within the broad scope of this disclosure. In some embodiments, aspects of the invention (e.g., surface classification) may be performed by software stored in storage subsystem 306, in memory 220 of a computer peripheral device, or in both. Those skilled in the art will appreciate many modifications, variations, and alternative implementations of this disclosure.

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

[0067] Each code module may include a set of instructions (code) implemented on a computer-readable medium, which instructs the processor of the host computing device 110 to execute corresponding actions. The instructions may be configured to execute sequentially, in parallel (e.g., under different processing threads), or in combination thereof. After the code modules are loaded onto a general-purpose computer system, the general-purpose computer is transformed into a special-purpose computer system.

[0068] Computer programs incorporating the various features described herein (e.g., in one or more code modules) can be encoded and stored on various computer-readable storage media. The computer-readable medium encoding the program code can be packaged with a compatible electronic device, or the program code can 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 can also store information useful for establishing network connections using communication interface 312.

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

[0070] 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, processing subsystem 302 can control the operation of computing device 300. In some embodiments, processing subsystem 302 can execute various programs in response to program code and can maintain multiple concurrently executing programs or processes. At a given time, some or all of the program code to be executed can reside in processing subsystem 302 and / or storage medium (e.g., storage subsystem 304). Through programming, processing subsystem 302 can provide various functions for computing device 300. Processing subsystem 302 can also execute other programs for controlling other functions of computing device 300, including programs that can be stored in storage subsystem 304.

[0071] The communication interface (also referred to as the network interface) 312 can provide voice and / or data communication capabilities to the computing device 300. In some embodiments, the communication interface 312 may include radio frequency (RF) transceiver components for accessing wireless data networks (e.g., Wi-Fi networks; 3G, 4G / LTE, etc.), mobile communication technologies, components for short-range wireless communication (e.g., using Bluetooth communication standards, NFC, etc.), other components, or combinations of technologies. In some embodiments, in addition to or instead of a wireless interface, the communication interface 312 may also provide wired connectivity (e.g., Universal Serial Bus (USB), Ethernet, Universal Asynchronous Receiver / Transmitter, etc.). The communication interface 312 can be implemented using a combination of hardware components (e.g., driver circuitry, antenna, modulator / demodulator, encoder / decoder, and other analog and / or digital signal processing circuitry) and software components. In some embodiments, the communication interface 312 may support multiple communication channels simultaneously.

[0072] User interface input device 314 may include any suitable computer peripheral device (e.g., computer mouse, keyboard, game controller, remote control, stylus device, etc.), as will be understood by those skilled in the art who benefit from this disclosure. User interface output device 316 may include display devices (e.g., monitor, television, projector, etc.), audio devices (e.g., speakers, microphones), haptic devices, etc. Note that the user interface input 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 where the keyboard and input elements, as well as the display and output elements, are integrated on the same host computing device. In some cases, such as Figure 1 As shown, the input and output devices can be separated from system 300. Those skilled in the art will appreciate many modifications, variations, and alternative implementations 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 not specifically described (e.g., voice communication via a cellular telephone network) and may include components suited to such functions. While 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 interfaces 314, 316, and communication interface 312 may be in one device or distributed across multiple devices. Furthermore, 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 depending on how the initial configuration is obtained, various blocks may or may not be reconfigurable. Embodiments of the invention can be implemented in various devices, including electronic devices implemented using a combination of circuitry and software. The host computing device or even peripheral devices described herein can be implemented using system 300.

[0074] Full Key Customization

[0075] As described above, aspects of the present invention relate to input devices with onboard systems (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 described further below. The remapped target data is sent to a communicatively coupled host computing device in a manner that provides excellent low latency (e.g., sub-millisecond reporting), accuracy, reliability, and consistency (e.g., immediate application of FKC upon wake-up / power-on), thereby contributing to an improved UX.

[0076] The following described implementations provide a novel and comprehensive Full Key Customization (FKC) framework to address the aforementioned problems and other FKC implementation challenges, including the management of FKC-based key combination triggering, modifier handling, key combination press / release events, modifier handling when linking key combinations, modifier suppression and re-enabling, conflicts, parallel key presses, and other logic, which will be described in detail below. At a high level, FKC distinguishes three independent layers: the base layer, the FN layer, and the GShift layer, each with similar behavior and capabilities. As those skilled in the art will understand from this disclosure, some implementations may have fewer or more layers. Within each layer, trigger keys can be of two types: single keys and key combinations. Target actions / behaviors can be of various types, including remapping to another key or shortcut, macros, button presses, etc. Modifiers specified in the target action can optionally be used to update the list of pressed logical modifiers. In doing so, the trigger key can be used to press one or more logical modifiers, which can then be used to construct trigger shortcuts. The triggering of key presses and key release events can optionally be notified to software operating on the host computing device (“host SW”). This can be used, for example, to implement a target action within the host SW. In some respects, GShift and FN can be supported as system-wide layer selectors, meaning that a user can 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 Examples of a base layer, FN layer, and GShift layer in an input device (e.g., keyboard 400, 140) utilizing an FKC system according to certain embodiments are shown. The base layer 410 includes keys that are directly accessible without pressing layer modifiers (e.g., FN, GShift). The FN layer 420 is the key accessible when the FN modifier is pressed, also referred to as the "function key" layer. The GShift layer 430 is the key accessible when the GShift modifier is pressed. (See reference...) Figure 4 Assign the same keys on the base layer and GShift layer instead of the FN layer.

[0078] Figure 5 and Figure 6 The logical results of certain key press combinations on an FKC-enabled keyboard 400 according to some embodiments are shown. Figure 5In flowchart 500, a user presses the "s" key (operation 502). The FKC keyboard 400 determines that the user has assigned the "s" key on the base layer to a different target (operation 504). That is, the "s" key on the base layer is the 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 communication-coupled lighting device). Therefore, when the "s" key on 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 is not customized, the default target output is performed (also known as "out-of-the-box" or "OOB" behavior) (operation 508).

[0079] Flowchart 520 illustrates the combination of the user pressing the "FN" key and the "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 switch the keyboard 400 to different corresponding host computing devices) (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 on the FN layer 420 is pressed, the user assignment on the FN layer is not activated (operation 526), ​​and the default assignment for "FN+s" is output (operation 527). If the "s" key on the FN layer is not user-customized and there is no default value assigned to the combination, either nothing happens or the system can revert to the default base layer (e.g., alphanumeric "s" output) (Operation 528).

[0080] exist Figure 6 In flowchart 600, the user presses the combination of the "GShift" key and the "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 the trigger, and the target is to turn off the output of the communication-coupled lighting device. Therefore, when the "s" key on the GShift layer 430 is pressed, the user assignment on the GShift layer is activated (operation 606). If no "s" key on the GShift layer is customized, the default target output is executed (also known as "out-of-the-box" or "OOB" behavior) (operation 608). In some cases, if no GShift OOB assignment applies, the system can revert to the OOB base layer assignment (e.g., alphanumeric "s" output).

[0081] Flowchart 620 illustrates a combination of the user pressing the “GShift” key, the “FN” key, and the “s” key (operation 622). At operation 624, the FKC keyboard 400 determines that the user has assigned the “s” key on the GShift layer to a different target. Furthermore, since both the GShift and FN layers are enabled, the GShift layer applies, but some implementations may differ in the level of the modifier. Therefore, the “s” key on the GShift layer is triggered, the FN layer is ignored, and the target is to turn off the output of the communication-coupled lighting device. Therefore, when the “s” key on 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 applies, the system can revert to the OOB base layer assignment of the “s” output (operation 628).

[0082] FKC Implementation

[0083] To provide a robust, FW-based FKC implementation with excellent latency and instant FKC functionality across a wide range of applications, several engineering challenges need to be addressed, including defining widely used key combination triggers, modifier handling (e.g., suppress and re-enable), key combination press and release events, key combination linking, conflicts, and more, which will be addressed separately below.

[0084] Define key combination trigger

[0085] In the context of FKC, key combination triggers 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). The key combination trigger occurs when the user presses the specified single physical key / button while the specified logical modifier key is being held down. Therefore, for example, users should expect to be able to customize the following key trigger / target mapping:

[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] Not so intuitive, users can also customize:

[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 key combinations 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 implementations, users can remap "key combinations" (e.g., modifier + key combinations) to any other key or key sequence. The design parameter is that this should work with any number of modifiers. The challenge in Example 1 (above) is that if the "x" key is intercepted and replaced with the "1" key, the output will be Shift + "1", which produces "!" (on a US keyboard) instead of "1". Therefore, a different way is needed to invalidate modifier keys that are already pressed by the user.

[0095] One option is to delay sending modifier keys to the host until it's determined that the underlying key combination is not customized. This approach is not optimal because it significantly impacts keyboard behavior, even when the user isn't pressing a customized key or shortcut. In other words, modifier keys may be suppressed even when triggered by a non-customized key, which can significantly affect the latency of the FKC system. Furthermore, some applications (e.g., games) directly use modifier key events, so not immediately sending modifier key events is unacceptable to many modern users.

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

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

[0098] Key press and release events

[0099] When supporting key combination triggers, the challenge lies in determining when a key combination is considered "pressed" and "released," and when the corresponding remapping target is "pressed" and "released." Note that key combination triggers are based on multiple underlying key presses: logical modifier keys and primary physical keys. In FKC, a key combination 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 implementations, releasing a modifier key does not release the underlying key combination trigger. Similarly, releasing a logical layer selection key (e.g., logical FN and logical GShift) does not release the underlying key combination (or single key) trigger.

[0100] Modifier handling (link shortcuts)

[0101] In some cases, users may want to "link" key combinations. For example, a user might want to quickly execute copy / paste commands sequentially by pressing "Ctrl+C" and "Ctrl+V" without having to release and re-press the Ctrl key between each combination. Within some key combination chains, some combinations can be customized, while others can remain uncustomized. This has several implications. If the FKC system ("FKC") artificially suppresses modifiers, and the user presses a non-customized key combination, then the FKC will need to unsuppress it. The FKC also needs to maintain a "logical" modifier state that is separate from the modifier press / release signals sent to the host computer's ("host") OS.

[0102] Cancel the suppress modifier

[0103] In some implementations, the suppression modifier may be deactivated when the user releases the underlying physical trigger key. However, this is not a preferred option, especially if 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 long to execute. If the FKC deactivates the suppression modifier early, it may interfere with the delayed execution of macro / remapping functionality. For example, if a 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, the FKC will suppress the left Ctrl modifier and begin macro execution. The user will then release "x", and if the left Ctrl is deactivated immediately, the macro may be affected, causing the OS to interpret the sequence as: "a", "b", "Left Ctrl+c", "Left Ctrl+d", "Left Ctrl+e", "Left Ctrl+f", instead of the correct output "a, b, c, d, e, f".

[0104] A better option is to configure FKC so that modifier desuppression does not occur when "x" is released, but only 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 desuppresses "Left Ctrl" and sends "y".

[0105] conflict

[0106] When a user presses a modifier key during macro playback, a conflict can occur, leading to unexpected behavior. In some cases, conflicts with remapping can also occur when implemented via a host switch (SW) rather than on a computer peripheral (e.g., via a firewall), because, as mentioned above, the relative timing of local keystrokes and keys injected by the host SW can conflict due to communication latency. For example, a user might configure "a" to be remapped to "x". In a host SW implementation, if the user then presses and releases "a" and immediately afterwards presses "Left Shift", the injection of "x" might be delayed until after "Left Shift" is pressed, resulting in an unexpected uppercase "X" output. Furthermore, the "cancel suppression" of modifiers can also cause conflicts in host SW implementations of key remapping systems.

[0107] Some general design principles that can help minimize the risk of conflicts include implementing remapping locally on computer peripherals (e.g., FKC based on the local firmware), implementing macros on computer peripherals (“input devices”) where possible (e.g., to minimize latency), and canceling suppressor modifiers when the user presses a subsequent key. In some implementations, the user can mark a macro such that the input device blocks all other keystrokes and modifier keys until the macro has completed, and that the macro should stop executing immediately once the user presses another key.

[0108] Parallel key press

[0109] Parallel key presses occur when a user presses and releases different keys remapped to the same target key. Compared to conventional systems, aspects of FKC based on the FW are able to handle this situation in a more reliable and consistent manner. 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 releasing “x” immediately or waiting until the user releases “a”. Once the user releases either of the trigger keys, some exemplary FKC implementations release the target.

[0110] Implicit Triggered Matching

[0111] In some implementations, FKC UX is configured such that if a user remaps a single trigger key to a single target key, the remapping occurs even if the user holds down one or more modifiers while pressing the trigger key. This is called "implicit" trigger matching, which differs from explicit matching, which would result in an exact match of all trigger keys, including the modifier key. For example, if a user remaps "a" → "x", it is expected that pressing "Shift" + "a" should result in "Shift" + "x" (uppercase X). In some aspects, implicit trigger matching may not apply between layers. Therefore, in the example above, if the user presses "Fn" + "a", or "G-Shift" + "a", no match will be produced implicitly or otherwise. More generally, FKC can be configured such that implicit matching does not occur when the user has already specified a key combination trigger (in which case only exact matching applies), or when the target is not a single key (e.g., the target is a macro). However, some implementations can employ a more flexible strategy where implicit trigger matching can apply to any type of trigger / target, including macros.

[0112] Notification host computing device SW

[0113] In some implementations, certain custom actions may require the host switch (SW) to perform. For example, injecting emojis or launching a specific application or game would involve the host switch. Therefore, this FW-based FKC provides a flexible way to notify the host switch of specific custom key triggers (e.g., single key or key combination) presses and releases. Reiterating the substantial importance of latency in FKC, and assuming a user can press multiple keys, an FKC implementation known as a dual-event system is used to send multiple notifications to the host switch in parallel. This dual-event system comprises both a bit-field-based event system and a list-based system. In the bit-field-based event system, each bit represents a different trigger in the FKC settings table (also known as the key remapping database), while in the list-based system, each trigger event is represented by a separate byte. The list-based method can be used when several keys are pressed simultaneously. The resulting short HID++ message can be carried on top of the underlying HID message. For cases where more custom keys are pressed, the bit-field method can support up to 128 simultaneous key press events. As those skilled in the art will understand from this disclosure, some implementations may use only one of the two systems, and some bit fields may support other simultaneous key press events.

[0114] Layered design

[0115] In some implementations, multiple layers are implemented in the FKC. As described above, the three layers include a base layer, an FN layer, and a GShift layer. The applied layer depends on whether the logical Fn key or the logical GShift key is pressed at the time, and which of the logical Fn key or 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 mouse 130 to GShift, which can enable GShift on keyboard 140). In some implementations, 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 [link to relevant documentation]). Figure 8 This can be configured and is completely interchangeable. In some cases, if not customized, layers can have specific default behaviors, such as... Figure 7 As shown.

[0116] Figure 7This is a simplified flowchart 700 illustrating aspects of a method 700 for FKC trigger matching according to certain embodiments. Method 700 can be executed by processing logic, which may include hardware (circuit systems, special-purpose logic, etc.), software operating on suitable hardware (e.g., general-purpose computing systems or special-purpose machines), firmware (embedded software), or any combination thereof. In some embodiments, method 700 can be executed by aspects of system 200 (e.g., processor 210 and memory block 220), system 300, or combinations thereof.

[0117] At operation 710, method 700 may include determining whether a logical GShift has been pressed, and, if true, retrieving data from the FKC GShift layer table (see, for example, ...). Figure 8 The corresponding group is searched for for matching in the GShift layer (operation 720). At operation 730, when a match is found, the FKC implementation (e.g., sending the key target to the host computing device) remaps the key target as indicated in the GShift layer table 810 (operation 770). At operation 730, when no match is found, the default (OOB) layer is searched, and the corresponding assignment is sent to the host computing device.

[0118] At operation 710, when logic GShift is false (not pressed), method 700 continues: determining whether logic FN is pressed (operation 715). When true, method 700 includes the FKC FN layer table (see, for example...). Figure 8 In operation 722, the FKC searches for the corresponding group in the FN layer table 820 for matching. In operation 732, when a match is found, the FKC implements the remapping key target indicated in the FN layer table 820 (operation 770). In operation 732, when no match is found, the FKC searches the default (OOB) FN layer (operation 740). In operation 750, when a match is found, the FKC continues to send the corresponding allocation to the host computing device. In operation 750, when no match is found, the FKC searches the default (OOB) layer (operation 760) and sends the corresponding allocation to the host computing device.

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

[0120] At operation 734, when a match is found, FKC implements the remapping key target indicated in 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 particular method 700 for FKC triggering matching according to certain embodiments. Other sequence of steps may also be performed according to alternative embodiments. Furthermore, additional steps may be added or removed depending on the specific application. Any combination of variations can be used, and many variations, modifications, and alternative embodiments of this disclosure will be understood by those skilled in the art who will benefit from it.

[0122] Figure 8 A lookup table 800 for multiple layers in an input device for FKC enabling, according to certain embodiments, is shown. Table 800 includes an FKC GShift layer table 810, an FKC FN layer table 820, and an FKC base layer table 830. Each table for a 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 unmodifiers. The target matrix stores the corresponding FKC targets, which include any combination of modifiers and unmodifiers (e.g., HID commands). Each trigger / target set can be indexed to enable searching.

[0123] Notify SW to trigger the press and release of the key

[0124] Many FKC target behaviors can be implemented within the input device itself; however, some FKC target behaviors cannot be implemented within the input device itself because these FKC target behaviors require execution by the host SW (e.g., emojis, launching applications, etc.). In some cases, applications can be enabled by allowing the host SW to know when a specific trigger key is pressed and released. Therefore, some implementations can employ the following FKC strategies: the host SW can be configured to send a notification when the user presses and releases any FKC trigger; the host SW can be configured to not have a local target behavior; and / or the notification can occur in parallel with the local target behavior. In some aspects, this can be achieved by using tables within a key remapping database (see, for example...). Figure 8 The FKC is configured using a table. Each row in the table can contain specific key triggers and associated behaviors. In some implementations, the host SW can assign an arbitrary trigger index to each row, which can be used to identify triggers when notifying the host SW. In some cases, two types of events are supported: 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 carried over the underlying HID event to avoid introducing any additional latency. If a relatively high number of trigger keys are being pressed (e.g., > 3), a long event format of bit field type can be used, which can simultaneously notify the host SW of up to 128 individual trigger key presses and releases, allowing the FKC system to always maintain at least 26 key flips.

[0125] Enable / Disable FKC

[0126] In FKC UX, users can access the system via a host (e.g., Logitech's). Alternatively, FKC can be enabled or disabled by pressing the FKC toggle hotkey on the corresponding input device. 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 flowchart illustrates an example of how an FKC-enabled input device can generate both default output and FKC output using the novel FKC innovation described above in a low-latency, consistent, and reliable manner.

[0129] Figure 9 This is a simplified flowchart illustrating aspects of a method 910 for remapping keys on an FKC-enabled input device (e.g., keyboards 140, 400) according to certain embodiments. Method 910 can be executed by processing logic, which may include hardware (circuit systems, dedicated logic, etc.), software operating on suitable hardware (e.g., general-purpose computing systems or dedicated machines), firmware (embedded software), or any combination thereof. In some embodiments, method 910 can be executed by system 200 (e.g., processor 210 and memory 220 for device 940 (e.g., keyboards 140, 400), system 300 (e.g., processor 302 and memory storage subsystem 306 for host computing device 110), or a combination thereof.

[0130] Method 910 illustrates a flowchart for remapping key triggers to key targets in an FKC-enabled input device. Specifically, the flowchart illustrates the 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, which identify various logical / HID modifier bitmaps, physical keys, corresponding flags and actions, etc., for FKC-enabled input devices to recognize the intended trigger / target pair.

[0131] Returning to reference method 910, user 920 can be a person, AI, etc., that interfaces with input device 940 (e.g., keyboard 140, 400). Operating system 960 can be MS... Or it may be any suitable operating system configured to operate as a platform to perform the FKC steps described herein directly or indirectly (e.g., through software running an OS). 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 protocols, as will be understood by one of ordinary skill in the art who benefits from this disclosure.

[0132] At operation 921, user 920 presses the "Left Shift" key on device 940. Device 940 can immediately send a "Left Shift" make command to OS 960 via HID report (operation 941). Then, user 920 presses the "x" key (operation 922), and device 940 sends an HID report with instructions to cause OS 960 to execute a "Left Shift" break command (e.g., a pause modifier) ​​and a "Left CTRL" enable command (operation 942), followed by a "y" enable command (operation 943). Then, user releases the "x" key (operation 923), and device 940 sends instructions to cause OS 960 to execute the "y" break command and the "Left Ctrl" break command (operation 944). Note that when the user presses "x," the device needs to pause "Left Shift" first because it has already been sent to the OS (as mentioned 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 first released from pause. This is because "Left Shift" needs to be applied in the default mode, since the combination of "Left Shift" and the new key cannot be found in FKC table 900. Therefore, "Left Shift" will now be applied, as detailed in the following sequence:

[0134] At operation 924, the user presses the "z" key while simultaneously pressing the "Left Shift" key from the previous sequence (operations 921 to 944). Device 940 then sends a "Left Shift" enable command (de-pause modifier—operation 945) and a "z" enable command (operation 946), thereby instantiating the "Left Shift+z" command at OS 960, which is non-FKC key triggered. When the user releases the "z" key (operation 924), device 940 sends a "z" interrupt command (operation 947). When the user releases the "Left Shift" key (operation 926), device 940 sends a "Left Shift" interrupt command 948. Note that, in response to the corresponding instructions from the input device, the modifier in the OS is paused and de-paused at different times to apply FKC-based customization and restore to non-FKC-based output, as required by the key sequence.

[0135] In the next key sequence, similar to the sequence above, when the user presses "Left Shift" + "x" (FKC triggered), the "Left Shift" modifier is paused. However, when the user releases "Left Shift," device 940 does not send an HID report because "Left Shift" has been paused. 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 the "Left Shift" key, and device 940 then sends a "Left Shift" enable command to OS 960. The user then presses the "x" key (operation 928), and 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 device 940 sends a "z" enable command to OS 960 (operation 952). At operation 931, the user releases the "z" key, and device 940 sends a "z" interrupt command (operation 953). At operation 932, the user releases the "x" key, and device 940 sends a "y" interrupt command and a "Left Ctrl" interrupt command to OS 960 (operation 954). Note that the target key is released when the corresponding physical trigger key is released.

[0137] It should be understood that, according to certain implementation methods, Figure 9The specific steps shown provide a particular method 900 for remapping keys on an FKC-enabled input device. According to alternative embodiments, other sequences of steps may also be performed. Furthermore, additional steps may be added or removed depending on the specific application. Any combination of variations can be used, and many variations, modifications, and alternative embodiments will be understood by those skilled in the art with the benefit of this disclosure.

[0138] Figure 10 This is a simplified flowchart illustrating aspects of a method 1010 for remapping keys on an FKC-enabled input device (e.g., keyboards 140, 400) according to certain embodiments. Method 1010 can be executed by processing logic, which may include hardware (circuit systems, dedicated logic, etc.), software operating on suitable hardware (e.g., general-purpose computing systems or dedicated machines), firmware (embedded software), or any combination thereof. In some embodiments, method 1010 can be executed by system 200 (e.g., processor 210 and memory 220 for device 1040 (e.g., keyboards 140, 400), system 300 (e.g., processor 302 and memory storage subsystem 306 for host computing device 110), or a combination thereof.

[0139] Method 1010 illustrates a flowchart for remapping key triggers to key targets in an FKC-enabled input device. Specifically, the flowchart illustrates the event sequence 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, which identify various logical / HID modifier bitmaps, physical keys, corresponding flags and actions, etc., for the FKC-enabled input device to identify the intended trigger / target pair. Referring to method 1010, user 1020, device 1040, and OS 1060 can respectively be similar to Figure 9 User 920, device 940 and OS 960.

[0140] At operation 1021, user 1020 presses the "Left Shift" key on device 1040. Device 1040 can immediately send a "Left Shift" enable command to OS 1060 via an HID report (operation 1041). Then, user 1020 presses the "w" key (operation 1022), and device 1040 sends an HID report with an instruction to cause OS 1060 to execute the "s" interrupt command (operation 1042). Note that "Left Shift" is not paused in this case (unlike method 900) because Left Shift is also present 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 situation, if the "Left Shift" key is still pressed and the user presses another key, the "Left Shift" command should be released first. At operation 1025, the user releases the "z" key, and device 1040 sends a "z" interrupt command to OS 1060. At operation 1026, the user releases the "Left Shift" key, and device 1040 sends a "Left Shift" interrupt command to OS 1060.

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

[0142] It should be understood that, according to certain implementation methods, Figure 10The specific steps shown provide a particular method 1000 for remapping keys on an FKC-enabled input device. According to alternative embodiments, other sequences of steps may also be performed. Furthermore, additional steps may be added or removed depending on the specific application. Any combination of variations can be used, and many variations, modifications, and alternative embodiments will be understood by those skilled in the art with the benefit of this disclosure.

[0143] Figure 11 This is a simplified flowchart illustrating aspects of a method 1110 for remapping keys on an FKC-enabled input device (e.g., keyboards 140, 400) according to certain embodiments. Method 1110 can be executed by processing logic, which may include hardware (circuit systems, dedicated logic, etc.), software operating on suitable hardware (e.g., general-purpose computing systems or dedicated machines), firmware (embedded software), or any combination thereof. In some embodiments, method 1110 may be executed by system 200 (e.g., processor 210 and memory 220 for device 1140 (e.g., keyboards 140, 400), system 300 (e.g., processor 302 and memory storage subsystem 306 for host computing device 110), or a combination thereof.

[0144] Method 1110 illustrates a flowchart for remapping key triggers to key targets in an FKC-enabled input device. Specifically, the flowchart illustrates the remapping of the "Left Ctrl" (key trigger) → "Left Shift" event sequence using logical modifier updates. The FKC table 1100 of the key remapping database includes key trigger 1102 and key target 1104 lookup tables, which identify various logical / HID modifier bitmaps, physical keys, corresponding flags and actions, etc., for the FKC-enabled input device to identify the intended trigger / target pair. Referring to method 1110, user 1120, device 1140, and OS 1160 can respectively... Figure 9 User 920, device 940 and OS 960.

[0145] At operation 1121, user 1120 presses the "Left Ctrl" key on device 1140. Device 1140 can immediately send a "Left Ctrl" enable command to OS 1160 via an HID report (operation 1141). Then, user 1120 presses the "a" key (operation 1122), and device 1140 sends an HID report with instructions to cause OS 1160 to execute the "a" enable command (operation 1142). At operation 1123, user releases the "a" key, and device 1140 sends an "a" interrupt command to OS 1160. At operation 1124, 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 typically determined by the OS based on whether the shift key is pressed. This concept can be applied to any of the examples presented herein. Send the "Left Shift" enable and "a" enable to the application, and the OS determines whether to apply the capital "A", as will be understood by one of ordinary skill in the art who will benefit from this disclosure.

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

[0147] It should be understood that, according to certain implementation methods, Figure 10 The specific steps shown provide a particular method 1000 for remapping keys on an FKC-enabled input device. According to alternative embodiments, other sequences of steps may also be performed. Furthermore, additional steps may be added or removed depending on the specific application. Any combination of variations can be used, and many variations, modifications, and alternative embodiments will be understood by those skilled in the art with the benefit of this disclosure.

[0148] Figure 12This is a simplified flowchart illustrating aspects of a method 1200 for remapping keys on an FKC-enabled input device (e.g., keyboard 140, 400) according to certain embodiments. Method 1200 can be executed by processing logic, which may include hardware (circuit systems, special-purpose logic, etc.), software operating on suitable hardware (e.g., general-purpose computing systems or special-purpose machines), firmware (embedded software), or any combination thereof. In some embodiments, method 1200 can be executed by system 200 (e.g., processor 210 and memory 220), system 300, or a combination thereof.

[0149] According to some implementations, at operation 1210, method 1200 may include: receiving (e.g., received 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 a first enable command indicating that a (logical) modifier is valid to a host computing device communicatively coupled to a keyboard by one or more processors. In some embodiments, the keyboard communicates with the host computing device via human-machine interface (HID) type commands.

[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 a keyboard is being pressed simultaneously, the second key being functionally assigned as a non-modifier alphanumeric character.

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

[0153] According to some implementations, at operation 1250 of method 1200, in response to determining that the combination of the first key and the second key is not included in the key remapping database as a key trigger, one or more processors send a third enable command (operation 1252) to the host computing device at the same time that the first key and the second key are pressed.

[0154] According to some implementations, 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 the (logical) modifier is invalid is sent to the host computing device by one or more processors at the same time the first key and the second key are pressed; and a second enable command corresponding to the key target in the remapping database associated with the combination of the pressed first key and the second key is sent to the host computing device by one or more processors at the same time the first key and the second key are pressed (operation 1254).

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

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

[0157] According to some implementations, at operation 1270, method 1200 may include receiving a third control signal by one or more processors 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 a key remapping database by one or more processors.

[0159] According to some implementations, at operation 1280, 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, method 1200 may include: sending a fourth enable command to the host computing device by one or more processors simultaneously with the first key and the third key being pressed, indicating that the (logical) modifier is switched from invalid to valid; and sending a fifth enable command to the host computing device by one or more processors simultaneously with the first key and the third key being pressed, corresponding to the default function assignment of the third key (operation 1282).

[0160] According to some implementations, 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: one or more processors sending a third enable command (operation 1284) to the host computing device at the same time that the first key and the third key are pressed.

[0161] It should be understood that, according to certain implementation methods, Figure 12The specific steps shown provide a particular method 1200 for remapping keys on an FKC-enabled input device. According to alternative embodiments, other sequences of steps may also be performed. Furthermore, additional steps may be added or removed depending on the specific application. Any combination of variations can be used, and many variations, modifications, and alternative embodiments will be understood by those skilled in the art with the benefit of this disclosure.

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

[0163] In implementations utilizing a web server as an operational or security server, the web server can run any of a variety of server or middleware applications, including HTTP servers, FTP servers, CGI servers, data servers, Java servers, and business application servers. The server can also respond to requests from user devices, for example, by executing one or more applications that can be implemented in any programming language or any scripting language and combinations thereof, including but not limited to... C, C#, or C++, and scripting languages ​​such as Perl, Python, or TCL. The server may also include a database server, including but not limited to those that can access databases from... and Database server acquired through commercial purchase.

[0164] Such devices may also include computer-readable storage medium readers, communication devices (e.g., modems, (wireless or wired) network cards, infrared communication devices, etc.), and working memory as described above. The computer-readable storage medium reader may be connected to or configured to receive non-transitory computer-readable storage media, thereby representing remote, local, fixed, and / or removable storage devices, as well as storage media for temporarily and / or more permanently containing, storing, transmitting, and retrieving computer-readable information. Systems and various devices will also typically include numerous software applications, modules, services, or other elements residing within at least one working memory device, including operating systems and applications such as client applications or browsers. It should be understood that alternative implementations may have many variations based on the implementations described above. For example, custom hardware may be used and / or specific elements may be implemented in hardware, software (including portable software, such as applets), or both. Furthermore, connections to other computing devices, such as network input / output devices, may be employed.

[0165] Numerous specific details are set forth herein to provide a thorough understanding of the claimed subject matter. However, those skilled in the art will understand that the claimed subject matter can be practiced without these specific details. In other instances, methods, apparatus, or systems known to those of ordinary skill have not been described in detail so as not to obscure the claimed subject matter. The various embodiments shown and described are provided merely 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 may be used or combined with other embodiments shown and described. Furthermore, the claims are not intended to be limited to any one of the exemplary embodiments.

[0166] Although the subject matter has been described in detail with reference to specific embodiments of the invention, it will be understood that those skilled in the art, upon gaining an understanding of the foregoing, will readily generate changes, modifications, and equivalents to such embodiments. Therefore, it should be understood that, as will be readily apparent to those skilled in the art, this disclosure is presented for illustrative purposes rather than limiting, and does not exclude such modifications, variations, and / or additions to the subject matter. In fact, the methods and systems described herein can be implemented in various other forms; furthermore, various omissions, substitutions, and changes can be made to the form of the methods and systems described herein without departing from the spirit of this disclosure. The appended claims and their equivalents are intended to cover such forms or modifications that fall within the scope and spirit of this disclosure.

[0167] While this disclosure provides certain exemplary embodiments and applications, other embodiments, including those not providing all the features and advantages set forth herein, will be apparent to those skilled in the art and are also within the scope of this disclosure. Therefore, the scope of this disclosure is intended to be limited only by reference to the appended claims.

[0168] Unless otherwise expressly stated, it should be understood that throughout this specification, discussions using terms such as “processing,” “operation,” “calculation,” “determine,” and “identify” refer to the actions or processing of computing devices, such as one or more computers or similar electronic computing devices, which manipulate or convert data represented as physical electronic or magnetic quantities within the memory, registers, or other information storage, transmission, or display devices of a computing platform.

[0169] The 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 provides a result conditioned on one or more inputs. Suitable computing devices include multi-functional microprocessor-based computer systems that access stored software that programs or configures the computing system from a general-purpose computing device to a dedicated computing device that implements one or more embodiments of this subject matter. The teachings contained herein may be implemented in the software used for programming or configuring the computing device using any suitable programming, scripting, or other type of language or combination of languages.

[0170] Implementations of the methods disclosed herein can be performed within the operation of such a computing device. The order of the boxes presented in the examples above can be varied—for example, the boxes can be reordered, grouped, and / or divided into sub-boxes. Some boxes or processes can be executed in parallel.

[0171] Unless otherwise specified or understood in the context, the conditional language used herein, such as "can," "may," "may," "may," "for example," etc., is generally intended to express that some examples include certain features, elements, and / or steps while other examples do not. Therefore, such conditional language is not generally intended to imply that one or more examples require features, elements, and / or steps in any way, 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 to be performed in any particular example.

[0172] The terms “comprising,” “including,” “having,” etc., are synonyms and are used inclusively in an open-ended manner, not excluding additional elements, features, actions, operations, etc. Furthermore, the term “or” is used in its inclusive sense (not its exclusive sense), such that, for example, when “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 implies open-ended and inclusive language, not excluding means suitable for or configured to perform additional tasks or steps. Additionally, the use of “based on” implies open-ended and inclusive language because a process, step, calculation, or other action “based on” one or more of the stated conditions or values ​​may actually be based on additional conditions or values ​​beyond those stated. Similarly, the use of “at least partially based on” implies open-ended and inclusive language because a process, step, calculation, or other action “at least partially based on” one or more of the stated conditions or values ​​may actually be based on additional conditions or values ​​beyond those stated. The headings, lists, and numbers included herein are for illustrative purposes only and are not intended to be limiting.

[0173] The various features and processes described above can be used independently of each other or in combination in various ways. All possible combinations and sub-combinations are intended to fall within the scope of this disclosure. Furthermore, in some embodiments, certain method or processing blocks may be omitted. The methods and processes described herein are not limited to any particular sequence, and the blocks or states associated with them may be executed in other suitable sequences. For example, the described blocks or states may be executed in a sequence other than that specifically disclosed, or multiple blocks or states may be combined as a single block or state. Example blocks or states may be executed serially, in parallel, or in some other manner. Blocks or states may be added to or removed from the disclosed examples. Similarly, the example systems and components described herein may be configured differently from those described. For example, elements may be added, removed, or rearranged compared to the disclosed examples.

Claims

1. A method comprising: The keyboard receives a first control signal from one or more processors, indicating that a first key on the keyboard is being pressed, the first key being functionally assigned as a modifier; The one or more processors send a first enable command indicating that the modifier is valid to a host computing device communicatively coupled to the keyboard; The processor receives a second control signal indicating that a second key on the keyboard is being pressed simultaneously, the second key being functionally assigned as a non-modifier alphanumeric character; The one or more processors access 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 on the keyboard, and each corresponding key target corresponding to a different function assignment compared to the default function assignment for the combination of one or more keys; 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: While the first key and the second key are pressed, one or more processors send a first interrupt command to the host computing device indicating that the modifier is invalid; as well as While the first key and the second key are pressed, one or more processors send a second enable command to the host computing device corresponding to a key target associated with the combination of the pressed first key and the second key in the remapping database; as well as 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, one or more processors send a third enable command to the host computing device corresponding to the alphanumeric character of the unmodifier of the second key.

2. The method according to claim 1, further comprising: The one or more processors receive an indication that the second key on the keyboard has been released; as well as The one or more processors send a second interrupt command to the host computing device, indicating that the key target is terminated.

3. The method according to claim 2, further comprising: The processor receives a third control signal indicating that a third key on the keyboard is being pressed while the first key is still being pressed; The key remapping database is accessed by one or more processors; as well as 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: While the first key and the third key are pressed, one or more processors send a third enable command to the host computing device corresponding to a key target associated with the combination of the pressed first key and the third key in the remapping database.

4. The method according to claim 3, 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, one or more processors send a fourth enable command to the host computing device, instructing the modifier to switch from invalid to valid; as well as While the first key and the third key are pressed, one or more processors send a fifth enable command to the host computing device corresponding to the default function assignment of the third key.

5. The method according to claim 4, further comprising: The one or more processors receive an indication that the third key on the keyboard has been released; A third interrupt command is sent from one or more processors to the host computing device, indicating that the default function allocation of the third key has been terminated; The one or more processors receive an indication that the first key on the keyboard has been released; as well as A fourth interrupt command, indicating that the modifier has been released, is sent from one or more processors to the host computing device.

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

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

8. The method according to claim 1, wherein, The keyboard communicates with the host computing device via HID type commands from the human-machine interface device.

9. A keyboard, comprising: One or more processors; A non-transitory computer-readable storage medium containing instructions configured to cause the one or more processors to perform operations, the operations including: The one or more processors of the keyboard receive a first control signal indicating that a first key on the keyboard is being pressed, the first key being functionally assigned as a modifier; The one or more processors send a first enable command indicating that the modifier is valid to a host computing device communicatively coupled to the keyboard; The processor receives a second control signal indicating that a second key on the keyboard is being pressed simultaneously, the second key being functionally assigned as a non-modifier alphanumeric character; The one or more processors access 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 on the keyboard, and each corresponding key target corresponding to a different function assignment compared to the default function assignment for the combination of one or more keys; and 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: Simultaneously with the pressing of the first and second keys, one or more processors send a first interrupt command to the host computing device indicating that the modifier is invalid; and Simultaneously with the pressing of the first and second keys, the one or more processors send a second enable command to the host computing device corresponding to a key target in the remapping database associated with the combination of the pressed first and second keys; and 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, one or more processors send a third enable command to the host computing device corresponding to the alphanumeric character of the unmodifier of the second key.

10. The keyboard according to claim 9, wherein, The instructions are also configured to cause the one or more processors to perform operations, the operations including: The one or more processors receive an indication that the second key on the keyboard has been released; and The one or more processors send a second interrupt command to the host computing device, indicating that the key target is terminated.

11. The keyboard according to claim 10, wherein, The instructions are also configured to cause the one or more processors to perform operations, the operations including: The processor receives a third control signal indicating that a third key on the keyboard is being pressed while the first key is still being pressed; The key remapping database is accessed by one or more processors; and 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: While the first key and the third key are pressed, one or more processors send a third enable command to the host computing device corresponding to a key target associated with the combination of the pressed first key and the third key in the remapping database.

12. The keyboard according to claim 11, wherein, The instructions are also 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 third key is not included as a key trigger in the remapping database: Simultaneously with the pressing of the first and third keys, one or more processors send a fourth enable command to the host computing device, instructing the modifier to switch from invalid to valid; and While the first key and the third key are pressed, one or more processors send a fifth enable command to the host computing device corresponding to the default function assignment of the third key.

13. The keyboard according to claim 12, wherein, The instructions are also configured to cause the one or more processors to perform operations, the operations including: The one or more processors receive an indication that the third key on the keyboard has been released; A third interrupt command is sent from one or more processors to the host computing device, indicating that the default function allocation of the third key has been terminated; The one or more processors receive an indication that the first key on the keyboard has been released; and A fourth interrupt command, indicating that the modifier has been released, is sent from one or more processors to the host computing device.

14. A nontransitory computer program product tangibly implemented in a machine-readable nontransitory storage medium, the machine-readable nontransitory storage medium including instructions configured to cause one or more processors to perform operations, the operations including: The one or more processors of the keyboard receive a first control signal indicating that a first key on the keyboard is being pressed, the first key being functionally assigned as a modifier; The one or more processors send a first enable command indicating that the modifier is valid to a host computing device communicatively coupled to the keyboard; The processor receives a second control signal indicating that a second key on the keyboard is being pressed simultaneously, the second key being functionally assigned as a non-modifier alphanumeric character; The one or more processors access 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 on the keyboard, and each corresponding key target corresponding to a different function assignment compared to the default function assignment for the combination of one or more keys; and 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: While the first key and the second key are pressed, one or more processors send a first interrupt command to the host computing device indicating that the modifier is invalid; as well as While the first key and the second key are pressed, one or more processors send a second enable command to the host computing device corresponding to a key target associated with the combination of the pressed first key and the second key in the remapping database; as well as 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, one or more processors send a third enable command to the host computing device corresponding to the alphanumeric character of the unmodifier of the second key.

15. The non-transitory computer program product according to claim 14, wherein, The instructions also cause one or more processors to perform operations, the operations including: The one or more processors receive an indication that the second key on the keyboard has been released; and The one or more processors send a second interrupt command to the host computing device, indicating that the key target is terminated.

16. The non-transitory computer program product according to claim 15, wherein, The instructions are also configured to cause the one or more processors to perform operations, the operations including: The processor receives a third control signal indicating that a third key on the keyboard is being pressed while the first key is still being pressed; The key remapping database is accessed by one or more processors; and 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: While the first key and the third key are pressed, one or more processors send a third enable command to the host computing device corresponding to a key target associated with the combination of the pressed first key and the third key in the remapping database.

17. The non-transitory computer program product according to claim 16, wherein, The instructions are also 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 third key is not included as a key trigger in the remapping database: Simultaneously with the pressing of the first and third keys, one or more processors send a fourth enable command to the host computing device, instructing the modifier to switch from invalid to valid; and While the first key and the third key are pressed, one or more processors send a fifth enable command to the host computing device corresponding to the default function assignment of the third key.

Images