USB协议和蓝牙协议对键盘延迟的影响-低调大师

USB协议和蓝牙协议对键盘延迟的影响

2020-07-31 1259

前一篇写了正在开发中的M60键盘的功耗，这篇就来聊一聊键盘的延迟~

键盘按键的延迟，即按下按键到电脑响应按键之间的时间差，其影响因素包括：通信协议限制（USB和蓝牙）、矩阵矩阵扫描方式（周期扫描或者中断检测扫描）、防抖方式、键盘微处理器处理速度、电脑处理速度，甚至键程……

其中，关键因素是通信协议限制，现在广泛使用的是USB和蓝牙，其它方式很多也是通过USB转换，同样受到USB限制。

测键盘的延迟比较难，简化一点，我们测一测的键盘响应速度，从响应速度大致可以了解键盘的延迟。这里用跑Python的M60键盘在Surface Book上测试，先说结论：

M60键盘采用USB连接，可以稳定地每 1.1~1.2ms 处理一个按键事件（按下或释放）；而采用低功耗蓝牙连接，则可以大概 3ms 处理一个按键事件，波动相对大。

USB对延迟的影响

键盘是USB中的标准 HID (Human Input Device) 设备，HID设备采用USB协议的中断传输方式 (Interrupt Transfer)，虽然名字中有中断二字，但实际上是电脑以大致的周期轮询设备，其中，最小的轮询间隔 (即中断间隔，Interrupt Interval) 可设置为1ms，即最高频率为1000Hz。因此，很多游戏键盘以1000Hz矩阵扫描频率，高了也没多少用。怎么测键盘的延迟呢？这里设计了一个小实验：

在Python键盘上，模拟字母a到z依次按下、释放、发送给电脑，在键盘端测量每次按键扫描、发送的处理时间，同时也在电脑端测量a到z按下、释放的时间间隔。

其中，键盘上的程序是这样的:

import time
import usb_hid

from matrix import Matrix

from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keycode import Keycode


matrix = Matrix()
keyboard = Keyboard(usb_hid.devices)

def alphabet_test():
    data = []
    t = time.monotonic_ns()
    for i in range(26):
        t1 = time.monotonic_ns()
        matrix.scan()
        keyboard.press(Keycode.A + i)
        t2 = time.monotonic_ns()
        matrix.scan()
        keyboard.release(Keycode.A + i)
        t3 = time.monotonic_ns()
        data.append((t2 - t1) // 100000 / 10.)
        data.append((t3 - t2) // 100000 / 10.)

    average = (time.monotonic_ns() - t) // (26 * 2 * 100000) / 10.
    print('average: {}, max: {}, min: {}, data: {}'.format(average, max(data), min(data), data))


while True:
    n = matrix.wait(10)
    if not n:
        continue

    keys = [matrix.get() for _ in range(n)]
    if keys[0] & 0x80:
        continue

    alphabet_test()

电脑端使用了keyboard库，代码如下：

import time
import keyboard


data = lambda: None
data.events = None

# {"event_type": "down", "scan_code": 29, "name": "ctrl", "time": 0, "is_keypad": false}
def print_pressed_keys(e):

    if e.name == 'a' and e.event_type == 'down':
        data.start = time.monotonic_ns()
        data.events = [e]
    elif data.events:
        data.events.append(e)
        if e.name == 'z' and e.event_type == 'up':
            data.end = time.monotonic_ns()
            t = []
            for i in range(1, len(data.events)):
                dt = data.events[i].time - data.events[i - 1].time
                dt = int(dt * 100000) / 100.
                t.append(dt)

            average = (data.end - data.start) // (len(data.events) * 100000) / 10.
            print('average: {}, max: {}, min: {}, data: {}'.format(average, max(t), min(t), t))
            data.events = None

keyboard.hook(print_pressed_keys)
keyboard.wait()

这里附上次4次测量数据，需要注意的是，键盘端测量是扫描+发送的处理时间，电脑端是两个按键事件的时间差。

键盘端测量数据

输出4串字母a到z，获得的扫描+发送的处理时间

average: 1.1, max: 1.1, min: 0.9, data: [0.9, 0.9, 1.0, 0.9, 1.0, 0.9, 0.9, 0.9, 1.0, 0.9, 1.0, 0.9, 1.0, 0.9, 0.9, 0.9, 1.0, 0.9, 1.0, 0.9, 1.0, 0.9, 0.9, 0.9, 1.0, 0.9, 1.0, 1.0, 1.0, 1.1, 1.0, 0.9, 1.0, 0.9, 1.0, 0.9, 1.0, 1.0, 1.0, 1.1, 1.0, 0.9, 0.9, 1.0, 1.0, 0.9, 1.0, 1.0, 1.0, 1.0, 1.0, 0.9]
average: 1.1, max: 1.1, min: 0.9, data: [1.0, 1.0, 1.0, 0.9, 1.0, 0.9, 1.1, 0.9, 1.0, 0.9, 1.0, 0.9, 0.9, 1.0, 1.0, 0.9, 1.0, 0.9, 0.9, 1.0, 1.0, 0.9, 1.0, 0.9, 1.0, 1.0, 0.9, 0.9, 1.0, 0.9, 1.0, 0.9, 1.0, 0.9, 1.0, 1.1, 1.0, 0.9, 1.0, 0.9, 0.9, 0.9, 1.0, 0.9, 1.0, 1.1, 0.9, 0.9, 1.0, 0.9, 1.0, 0.9]
average: 1.1, max: 1.2, min: 0.9, data: [1.0, 1.0, 1.0, 1.1, 1.0, 0.9, 1.0, 0.9, 1.0, 0.9, 1.0, 1.0, 1.1, 0.9, 0.9, 1.0, 1.0, 0.9, 1.0, 0.9, 1.0, 1.0, 1.1, 0.9, 1.0, 0.9, 1.0, 0.9, 1.0, 0.9, 0.9, 1.0, 1.2, 0.9, 1.0, 1.0, 1.0, 0.9, 1.0, 0.9, 1.0, 0.9, 1.1, 0.9, 1.0, 0.9, 1.0, 0.9, 0.9, 1.0, 1.0, 0.9]
average: 1.1, max: 1.1, min: 0.9, data: [1.0, 1.0, 1.0, 1.0, 0.9, 1.0, 1.0, 1.0, 1.1, 0.9, 0.9, 1.0, 1.0, 0.9, 1.0, 0.9, 1.0, 1.0, 1.1, 0.9, 1.0, 0.9, 1.0, 0.9, 0.9, 1.0, 1.0, 0.9, 1.1, 0.9, 0.9, 1.0, 1.0, 0.9, 1.0, 0.9, 1.0, 0.9, 1.0, 0.9, 1.0, 0.9, 1.0, 0.9, 0.9, 1.0, 1.0, 1.0, 1.0, 0.9, 0.9, 1.0]

电脑端测量数据

输入4串字母a到z，获得的按键事件时间间隔

average: 1.2, max: 4.02, min: 0.0, data: [3.82, 2.68, 2.0, 4.02, 0.99, 0.99, 1.99, 2.94, 2.99, 0.99, 1.0, 0.99, 1.99, 0.0, 2.0, 0.98, 0.99, 0.99, 0.99, 0.99, 0.99, 0.0, 0.99, 0.99, 0.99, 0.0, 0.99, 0.99, 0.0, 0.99, 0.99, 0.0, 0.99, 0.99, 0.0, 0.99, 0.0, 0.99, 0.0, 0.99, 0.99, 1.0, 0.99, 0.99, 1.01, 1.88, 1.0, 0.0, 1.1, 1.0, 0.99]
average: 1.2, max: 2.76, min: 0.0, data: [1.99, 1.99, 1.99, 1.95, 2.0, 0.99, 1.99, 2.76, 1.83, 1.0, 0.99, 0.0, 0.99, 0.99, 1.0, 0.99, 0.99, 0.99, 1.99, 0.99, 1.99, 0.99, 1.99, 1.99, 0.99, 0.99, 0.99, 0.0, 1.0, 0.99, 0.99, 0.0, 0.99, 0.0, 0.99, 0.99, 0.0, 0.99, 0.0, 0.99, 0.99, 1.0, 0.99, 1.0, 0.99, 1.99, 1.89, 1.02, 1.77, 1.45, 0.84]
average: 1.2, max: 3.14, min: 0.0, data: [0.95, 1.98, 3.14, 1.95, 2.02, 2.89, 2.6, 2.11, 1.0, 1.0, 0.99, 0.0, 0.99, 0.99, 0.99, 0.99, 0.0, 0.99, 0.0, 1.67, 0.85, 1.0, 0.0, 0.99, 0.99, 0.0, 0.99, 0.0, 0.99, 1.99, 1.0, 1.19, 1.35, 1.12, 1.0, 0.99, 0.99, 1.0, 0.99, 0.99, 1.0, 1.9, 0.96, 1.0, 0.99, 1.0, 0.98, 2.03, 2.9, 0.99, 1.02]
average: 1.1, max: 4.51, min: 0.0, data: [1.0, 0.99, 2.99, 1.99, 1.92, 1.35, 4.41, 4.51, 0.0, 1.99, 0.99, 0.99, 3.0, 1.98, 0.99, 1.0, 0.99, 1.36, 1.59, 1.0, 0.99, 0.99, 0.99, 1.01, 1.98, 1.98, 1.0, 0.0, 0.99, 0.99, 0.99, 0.0, 0.99, 0.99, 1.99, 0.99, 0.99, 1.99, 0.99, 1.99, 1.01, 2.02, 1.52, 2.63, 1.94, 0.99, 0.0, 0.99, 0.99, 1.11, 1.01]

从数据数据中可以看出，键盘端的数据要稳定一些，电脑端波动大一些，也许是因为Windows系统的非实时性导致获得事件时间不太准确。

接下来，分析一下蓝牙协议对延迟的影响，这里关注的是低功耗蓝牙（Bluetooth Low Energy，BLE）。

BLE对延迟的影响

BLE在对键盘的支持上借用了USB HID协议，设计了一个叫 HID over GATT 的蓝牙 Profile。在BLE协议中，对延迟影响最大是两个设备连接之后的连接间隔（Connection Interval）。在不同的系统上，最小的连接间隔有所不同，其中，Android上最小为7.5ms；苹果系统上最小可以到11.25ms；Windows上，没用找说明，Surface Book上实测最小为11.25ms。

这里的连接间隔和前面USB HID的中断间隔是不同的，因为蓝牙的一个连接间隔里面可以发几包数据，而最大是几包，这又是因系统而异：Android上可以发6包数据；苹果系统上是4，Windows上结合下面的数据可能是6。

那么，键盘在Android上最快是每秒发 1000 * 6 / 7.5 = 800 次数据，平均间隔 1.25 ms；苹果系统上，最快是 1000 * 4 / 11.25 ~= 355 次/s，平均间隔 2.8125 ms；Windows上，可能是 1000 * 6 / 11.25 ~= 533 次/s，平均间隔 1.875 ms。

套用前面的小实验，把USB键盘改成蓝牙键盘测一下，电脑端代码不用变，键盘代码更改如下：

import time
import usb_hid
from matrix import Matrix
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keycode import Keycode
import adafruit_ble
from adafruit_ble.advertising import Advertisement
from adafruit_ble.advertising.standard import ProvideServicesAdvertisement
from adafruit_ble.services.standard.hid import HIDService
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keycode import Keycode


ble_hid = HIDService()
advertisement = ProvideServicesAdvertisement(ble_hid)
advertisement.complete_name = 'PyKeyboard'
advertisement.appearance = 961
ble = adafruit_ble.BLERadio()
ble.name = 'PyKeyboard'
if ble.connected:
    for c in ble.connections:
        c.disconnect()
ble.start_advertising(advertisement)

keyboard = Keyboard(ble_hid.devices)
# keyboard = Keyboard(usb_hid.devices)

matrix = Matrix()

def alphabet_test():
    data = []
    t = time.monotonic_ns()
    for i in range(26):
        t1 = time.monotonic_ns()
        matrix.scan()
        keyboard.press(Keycode.A + i)
        t2 = time.monotonic_ns()
        matrix.scan()
        keyboard.release(Keycode.A + i)
        t3 = time.monotonic_ns()
        data.append((t2 - t1) // 100000 / 10.)
        data.append((t3 - t2) // 100000 / 10.)

    average = (time.monotonic_ns() - t) // (26 * 2 * 100000) / 10.
    print('average: {}, max: {}, min: {}, data: {}'.format(average, max(data), min(data), data))

while True:
    n = matrix.wait(10)
    if not n:
        continue

    keys = [matrix.get() for _ in range(n)]
    if keys[0] & 0x80:
        continue

    if ble.connected:
        for c in ble.connections:
            if c.connection_interval > 11.25:
                c.connection_interval = 11.25
            print('ble connection interval {}'.format(c.connection_interval))
    else:
        continue

    alphabet_test()

同样附上4次测量数据~

键盘端测量数据

ble connection interval 11.25
average: 2.7, max: 31.6, min: 1.0, data: [1.1, 1.0, 1.1, 1.0, 1.1, 1.0, 1.1, 1.0, 1.1, 1.0, 1.1, 31.6, 1.1, 1.0, 1.1, 1.0, 1.1, 1.0, 1.2, 1.5, 1.1, 1.0, 1.1, 1.0, 1.1, 1.0, 1.1, 1.1, 2.1, 2.0, 1.9, 1.0, 1.1, 1.0, 1.1, 1.8, 1.1, 1.0, 1.1, 1.0, 1.1, 1.0, 1.2, 23.3, 1.8, 1.2, 1.1, 18.0, 2.1, 2.1, 1.1, 1.0]
ble connection interval 11.25
average: 2.0, max: 19.9, min: 1.0, data: [1.2, 1.1, 1.1, 1.0, 1.1, 1.1, 1.2, 1.5, 1.1, 1.0, 1.1, 1.0, 1.1, 1.0, 1.2, 1.3, 11.4, 2.1, 2.1, 1.9, 1.8, 1.4, 1.9, 1.2, 1.1, 1.0, 1.1, 1.0, 1.2, 1.2, 1.1, 1.0, 19.9, 1.0, 1.1, 1.0, 1.1, 1.0, 1.1, 1.0, 1.1, 2.0, 1.1, 1.0, 1.1, 1.0, 1.1, 1.0, 1.2, 1.7, 2.1, 1.4]
ble connection interval 11.25
average: 3.5, max: 36.6, min: 1.0, data: [1.2, 1.1, 1.1, 1.1, 1.2, 1.2, 1.3, 1.0, 1.1, 1.0, 1.1, 27.8, 1.1, 1.0, 1.1, 1.0, 1.1, 1.0, 1.2, 1.5, 1.4, 1.0, 1.1, 1.0, 1.1, 1.0, 1.2, 1.0, 1.7, 1.0, 1.1, 1.0, 1.1, 1.0, 1.1, 36.6, 2.0, 1.1, 1.1, 1.0, 15.9, 2.0, 1.3, 1.0, 6.2, 1.8, 1.1, 30.4, 2.1, 2.2, 2.0, 1.3]
ble connection interval 11.25
average: 2.6, max: 34.3, min: 1.0, data: [1.1, 1.1, 1.1, 1.0, 1.1, 1.2, 1.1, 1.0, 1.1, 1.0, 1.1, 28.1, 1.1, 1.0, 1.1, 1.0, 1.1, 1.0, 1.3, 1.5, 2.0, 1.0, 1.1, 1.0, 1.1, 1.0, 1.2, 1.6, 1.1, 1.0, 1.1, 1.0, 1.1, 1.0, 1.1, 1.2, 34.3, 2.0, 2.2, 2.0, 1.8, 1.4, 1.9, 2.0, 2.0, 2.0, 1.1, 1.6, 1.2, 1.0, 1.1, 1.0]

电脑端测量数据

average: 3.9, max: 38.06, min: 0.0, data: [2.53, 8.0, 11.95, 0.99, 0.99, 0.99, 1.0, 0.99, 0.99, 5.16, 0.99, 0.66, 31.19, 1.02, 0.61, 20.85, 1.02, 0.99, 0.99, 1.0, 1.0, 0.99, 0.99, 38.06, 1.02, 0.0, 10.36, 0.0, 1.0, 0.99, 9.1, 1.0, 1.98, 1.0, 0.99, 0.98, 0.99, 0.99, 0.0, 1.0, 0.99, 0.0, 1.13, 1.01, 0.0, 0.98, 1.0, 1.34, 0.0, 29.67, 1.0]
average: 1.5, max: 24.81, min: 0.0, data: [1.95, 0.99, 1.98, 0.0, 0.99, 0.0, 0.99, 0.99, 0.0, 0.99, 0.99, 0.0, 0.99, 0.99, 0.0, 1.0, 0.77, 0.44, 1.7, 1.0, 0.0, 0.99, 0.74, 1.44, 0.0, 6.98, 0.99, 1.0, 0.0, 1.0, 1.98, 6.38, 0.99, 0.0, 0.99, 2.99, 1.0, 0.99, 0.99, 0.99, 0.0, 24.81, 1.02, 1.0, 1.99, 0.99, 1.0, 0.98, 1.79, 0.0, 2.0]
average: 3.3, max: 33.06, min: 0.0, data: [0.95, 1.99, 1.99, 0.98, 0.0, 0.99, 1.4, 1.0, 18.18, 1.02, 0.0, 0.99, 9.6, 0.0, 1.0, 33.06, 0.0, 0.99, 1.0, 0.0, 0.99, 1.0, 0.99, 0.99, 0.0, 0.99, 0.0, 1.0, 25.08, 1.0, 0.99, 0.0, 1.09, 30.51, 22.63, 1.0, 0.0, 0.99, 0.99, 1.99, 0.99, 0.0, 0.99, 1.01, 0.0, 0.0, 2.12, 0.86, 1.0, 0.99, 0.73]
average: 2.7, max: 62.49, min: 0.0, data: [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 15.63, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 47.03, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 62.49, 0.0, 0.0, 0.0, 15.44]

从数据中，可以看出通过蓝牙连接，延迟波动比较大，最大延迟可达 62.49 ms，最小可到 1 ms（忽略数据中的0）。由于蓝牙键盘延迟不确定，最大延迟较大，看起来不太适合用来玩实时性要求很高的游戏。而日常打字敲代码没啥问题。键盘端和电脑端的数据有差异，不过在同一个数量级，能大致反应出键盘的延迟。

参考

微信关注我们

原文链接：https://my.oschina.net/u/4557749/blog/4462045

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

你现在可以使用的10个JavaScript代码段

云栖号资讯：【点击查看更多行业资讯】在这里您可以找到不同行业的第一手的上云资讯，还在等什么，快来！毫无疑问，JavaScript是Web开发中最流行的编程语言之一。无论您使用的是React，Vue还是Angular，都只是JavaScript。围绕JS展开了广泛而重要的生态系统，提供了无数的框架和库，可帮助你更快地开发应用程序。但是有时候最好退一步，尝试了解如何在没有库的情况下做事。看看下面的代码片段，以优雅的方式解决简单的问题，并在日常项目情况下使用这些知识或为编码面试做准备。 1.反转字符串在此示例中，我们使用扩展运算符（…），Array的reverse方法和String的join方法来反转给定的字符串。 const reverseString = string => [...string].reverse().join(''); // 例子 reverseString('javascript'); // 'tpircsavaj' reverseString('good'); // 'doog' 2.计算数字的阶乘要计算给定数字的阶乘，我们使用箭头函数和嵌套三元运算符...

2020-08-03

615

如果业务对查询延迟很敏感，Elasticsearch 查询延迟中的毛刺现象就是比较困扰的一类问题，由于出现毛刺的时间点已经过去，无法稳定复现，对于根因的分析比较困难，无法用系统化调试的思想，从现象出发逐步推理，定位问题，能做的通常就是看一下监控系统对应时间点的指标情况，而在 es 中，导致查询延迟发生波动的因素非常多，今天我们来列举一下可能的因素，并尝试用对应的方法来定位和解决他们。通常一个系统中会有多种不同的查询同时存在，他们本身正常的查询延迟就可能存较大差异，因此即使系统在理想状态下，查询延迟的曲线也可能存在较大波动，特别是查询条件不固定，某些查询本身就耗时较长。我们只讨论一个特定的查询语句在某个时刻产生了较大延迟，即这个查询语句正常不应该耗时那么久。另外 es 和 lucene 层面的查询缓存只是一种优化，查询缓存本身并不能保证查询延迟，因此不在本文讨论范畴。 GC 的影响查询延迟受 GC 的影响是常见因素之一，一个查询被转发的相关分片，任意节点产生一个长时间的 GC 都会导致整个查询耗时变长。定位方式：查看对应时间点的节点 GC 指标，参考 kibana 或 gc lo...

2020-08-02

577

资源下载

更多资源

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。