<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0"><channel><title><![CDATA[键鼠助手5.0]]></title><description><![CDATA[键鼠助手5.0]]></description><link>https://www.byteohm.com/category/5</link><generator>RSS for Node</generator><lastBuildDate>Thu, 19 Nov 2026 05:29:59 GMT</lastBuildDate><atom:link href="https://www.byteohm.com/category/5.rss" rel="self" type="application/rss+xml"/><pubDate>Thu, 05 Nov 2026 17:06:32 GMT</pubDate><ttl>60</ttl><item><title><![CDATA[键盘采样：让盒子认识你那把键盘]]></title><description><![CDATA[盒子夹在电脑和键盘之间：电脑看到的是盒子，你的按键要先经过盒子转一手才能到电脑。这一手能不能转对，取决于盒子知不知道你这把键盘的报文长什么样。
多数键盘用标准格式，盒子自带的那套就够。但另一类键盘不一样：全键无冲用位图、把修饰键和键码拆成两个 report、自己加了 report ID、或者把功能键丢在另一个用途页里。碰上这类键盘，默认格式对不上，键就转不过去。
键盘采样就是给这类键盘用的：采一次，盒子以后按你这把键盘的格式来。
能解决什么问题
出现下面这些症状，先试采样：



症状
具体表现




某些键完全不认
按了电脑没反应，别的键都正常


按住不放变成连击
按住 Shift 走出来一串 Shift，按住方向键光标乱跳


组合键只过去一半
Ctrl+C 到电脑只剩 C，Ctrl+Shift+Esc 只出一个键


功能键、多媒体键失效
主键区正常，上面一排或者侧键不通


换了键盘就出问题
上一把键盘好好的，换这一把就不对



如果整把键盘都不工作、设备根本识别不到，那不是采样的范围，见《设备识别、固件更新与恢复》。
做完之后是什么效果

盒子换成你这把键盘的身份：VID/PID、报文格式都跟着它走，电脑那边认到的就是这把键盘。
状态行显示 Mode: 透传 表示生效了。显示「固定」说明连的还是盒子自己的身份，采样没起作用。
宏不用改。 脚本里的 KeyTap("a") 还是 KeyTap("a")，变的是这一下按键最终以什么格式发出去，采完不用回去改脚本。
可以存下来复用。 采样结果能导出成 .kmps，换机器、恢复出厂之后导回去，不用重采。
采样只读键盘自报的身份信息，不记录你按过的任何键。

操作前先确认



条件
说明




设备要支持
仅新设备具备这个能力，老设备点了不会有回应


设备已激活
未激活的设备不执行采样，直接回错误码 -8


键盘插在盒子上
采样时盒子要能枚举到它，插在电脑上采不到


用键鼠透传程序
采样按钮在键鼠透传里，不在键鼠助手主程序里；两个程序装在同一目录




之前手填过 VID/PID（见《USB 协议自定义》）的，采样之后以采样结果为准，手填的那两个值会被覆盖。

操作步骤

打开键鼠透传。 与键鼠助手同目录的另一个程序。
按压按键。保持按压状态把键鼠透传设备插入电脑。
连接设备。 第一次连不要勾「仅连接」——此时盒子还是它自己的身份，全枚举就能找到。
点底部的「KM 采样」。 按钮变成「采样已发出」，等回包。
看结果。 成功时会提示 采样设备: VID xxxx / PID xxxx，同时这对 ID 自动填进连接条的 VID/PID 框，并自动勾上「仅连接」——设备重启后已经换了身份，不点名就找不到了。(部分设备不会填入VID/PID，可以忽略这个，不影响纯硬件宏使用，只是无法通过软件API调用键鼠事件)。如果没有弹出VID/PID框，也不需要上位机调用，如果想再试连接，重复第2步。如果需要上位机调用，可以换个其它的键鼠设备尝试一下，一般支持板载宏的键鼠都支持，但是并不代表不支持板载宏的键鼠就不支持，只是概率会小很多。
手动点一次「连接」。 采样成功后设备会重启，此时链路是断的。
确认模式。 连接条状态行显示 Mode: 透传 才算成了。显示「固定」说明这次连的还是设备自己的身份。


采样命令发出去后 6 秒没有回应，程序会提示「设备没有回应采样命令」。常见原因：设备没激活、固件太旧不支持、链路已断。

备份与迁移
采样结果能取出来，也能写回去：



按钮
作用




导出
把设备里的采样镜像读出来，存成 .kmps 文件


导入
把 .kmps 写进设备，写完设备自动重启



两种用途：同一型号的键盘有好几把，采一次导出、其余几台导入；或者设备要升级固件、恢复出厂之前先把镜像存一份。

.kmps 里装的是某个键盘型号的 USB 身份。导入来源不明的文件，等于让盒子冒充你没见过的设备。要恢复就换回自己那份，别拿别人给的当通用备份。

遇到问题如何处理
采样失败，弹了错误码
提示格式是「采样失败（错误码 N）：说明」：



码
含义
一般怎么处理




-1
没有找到兼容的 USB 设备
键盘没插在盒子上，或插了但不兼容


-2
读设备描述符失败
换线、换口再试


-3
读配置描述符失败
同上


-4
读 HID 报文描述符失败
复合设备容易卡在这步，换口重试


-5
采样数据写入设备失败
设备存储异常，重试；仍失败联系售后


-6
采样数据超出存储上限
描述符太大，多见于 report 很多的自定义键盘


-7
采样超时
键盘响应慢或中途掉了，重插再采


-8
设备未激活
先激活


-9
设备没有回传 VID/PID
固件过旧，见《设备识别、固件更新与恢复》



提示采样成功，但连不上设备
设备重启成新身份，而程序的自动重连还在用旧 VID/PID，必然连不上。这不是坏了，手动点一次「连接」。
采完个别键还是不对
按顺序核两件事：键盘是不是插在盒子上采的；连接后状态行是不是 Mode: 透传。两步都对仍有键不对，说明这把键盘的报文里有盒子没覆盖的字段——带上键盘型号和当时的错误码发帖，比只说「有个键按不出来」有用得多。
换了一把键盘，之前采的还能用吗
不能。采样绑的是那一把键盘，换一把报文格式不同的要重采。
什么时候该重新采样
换键盘、键盘换了 USB 口之后行为变了、或者升级固件后提醒重采——这几种情况重新采一次。日常换机器、重装程序不用重采，把 .kmps 导回去就行。
相关

盒子的身份是怎么被系统识别的：见《USB 协议自定义：VID/PID 与字符串描述符》；
版本信息、固件更新与恢复：见《设备识别、固件更新与恢复》。

]]></description><link>https://www.byteohm.com/topic/76/键盘采样-让盒子认识你那把键盘</link><guid isPermaLink="true">https://www.byteohm.com/topic/76/键盘采样-让盒子认识你那把键盘</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 17:06:32 GMT</pubDate></item><item><title><![CDATA[键鼠助手 Lua 宏脚本合集 · 目录]]></title><description><![CDATA[这个版块里目前有 23 篇宏脚本相关的帖子。版本更新后这个目录会同步维护，按下面的顺序读最省时间。
第一次用，从这里开始

写在前面：这些脚本怎么用、什么不该做 — 这套东西擅长什么、什么不做，先看这篇
从零到烧录：五步做出第一个宏 — 编辑 → 编译 → 运行 → 绑定 → 烧录 → 验证

脚本基础
不读懂这几篇，后面所有脚本都只能照抄不能改。

Lua 语法速查：这套脚本到底是不是 Lua — 与标准 Lua 的六处差异，数组下标从 0 开始是最大的坑
内置函数与 HID 键码对照表 — 15 条命令 + 9 个函数 + 全部键码，可查表
延时精度与宏时长预算 — 「误差小于 1ms」到底意味着什么，宏实际耗时怎么算
调试三件套：编译、验证、Log — 报错怎么读、软件验证与真机的差异

图形化编程
不想写代码也能做宏，和文本模式是同一份脚本的两种看法。

图形化块编程入门 — 8 组块、三种放入方式、一个完整例子
块编辑器的操作细节 — 多选、复制、撤销、条件分支追加、缩放

按场景用

一键输入常用长文本：TypeText 的两种模式 — 地址、模板、编号；GBK 与 Unicode 的区别
把一串重复操作压成一次按键 — 组合键序列，以及延时该给多少
Photoshop 高频操作宏：图层、笔刷、定位 — 笔刷归零到固定档位、坐标定位
剪辑软件的时间轴宏：Pr 与剪映 — 切一刀 + 波纹删除，批量粗剪
可控频率连点器：从死循环到带抖动 — 频率到底怎么算，MouseClick 的 20ms 天花板
按住连发与三种触发方式的组合 — 选错触发方式是「宏不生效」的高频原因

单机游戏
仅限单机 / 离线 / 自带训练场，不涉及任何联机对战。

单机游戏宏的边界：能做什么、不能做什么 — 先看这篇，边界在这里
重复采集与刷素材的循环宏 — 四段式循环、参数化、分批执行
连招与技能循环的时间轴写法 — 时间轴、抖动、长按型技能的处理

设备与排错

编译通过但设备不动作：排查清单 — 按五条顺序查，能解决大部分问题
常见报错与处理 — 编译期、运行期、连接、崩溃四类
设备识别、固件更新与恢复 — 版本信息、自动加载宏的坑、烧录失败排查
USB 协议自定义：VID/PID 与字符串描述符 — 改 ID 的用途与风险
键盘采样：让盒子认识你那把键盘 — 把键盘描述符采进盒子，之后以它的身份出现
无线接收器重绑与格式化 — 重绑是安全的，格式化不是

几个通用提醒
改完脚本要重新烧录。 只点「编译」不烧录，硬件里跑的还是旧版本——这是最高频的「明明改了却没生效」。
软件里跑通不等于硬件里一致。 软件侧解释执行，硬件侧是字节码在盒子上跑。
while true 之前先配好终止键。 默认是 ESC，插小键盘或只用鼠标的话可能按不到。
遇到问题先看第二栏。 按下触发键，状态栏第二栏变绿说明宏在跑，问题在输出端；不变绿说明触发没进来。这一条能把排查范围砍掉一半。
]]></description><link>https://www.byteohm.com/topic/75/键鼠助手-lua-宏脚本合集-目录</link><guid isPermaLink="true">https://www.byteohm.com/topic/75/键鼠助手-lua-宏脚本合集-目录</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:43 GMT</pubDate></item><item><title><![CDATA[连招与技能循环的时间轴写法]]></title><description><![CDATA[连招的本质是一条时间轴：每个动作在什么时刻按下、间隔多久。宏做这件事的能力恰好够用——它能精确控制时间，但完全不知道技能有没有放出去。

适用范围：仅单机 / 离线 / 自带训练场。不适用于任何联机对战模式。

最小版本：顺序 + 间隔
-- 三段连招
KeyTap("1")
Delay(180)
KeyTap("2")
Delay(220)
KeyTap("3")

Delay 的值等于**「上一个动作的动画 / 后摇时长」**，不是「你手的速度」。取值方法：在训练场放一次，数出下一个技能能接上的最早时刻，再减 20ms 作为余量——这 20ms 不是玄学，KeyTap(key) 展开就是 KeyDown → Delay(20) → KeyUp，技能键自己要先占住 20ms 的按下时间，之后才开始算你给的 Delay。
用函数封装，避免重复
连招一长，重复的 KeyTap + Delay 会写满整屏。封装一下：
function cast(key, wait_ms)
    KeyTap(key)
    Delay(wait_ms)
end

-- 三段连招现在是这样
cast("1", 180)
cast("2", 220)
cast("3", 300)

想改某个技能的间隔，只改调用处那一个数字。
循环：固定节奏的技能循环
单机游戏里常见的「技能循环」是按固定顺序反复施放：
local CYCLE = 6                 -- 循环轮数

for i = 1, CYCLE do
    cast("1", 150)
    cast("2", 150)
    cast("3", 150)
    cast("4", 900)              -- 4 是长 CD 技能，等它转好
end

关键判断：这段等待时间里，你的角色是不是什么都不做？ 如果答案是「是」，那这个循环是浪费；如果能塞进普攻，就把普攻塞进去：
for i = 1, CYCLE do
    cast("1", 150)
    cast("2", 150)
    KeyTap("q")                 -- 普攻
    Delay(600)
    cast("3", 150)
    cast("4", 900)
end

抖动：让节奏不那么机械
固定间隔在单机里主要是为了「手感不假」，在带在线组件的游戏里还有一层意义——完全等间隔的输入是自动化检测最容易识别的特征。
function castJitter(key, base_ms, jitter_ms)
    KeyTap(key)
    Delay(base_ms + math.random(-jitter_ms, jitter_ms))
end

单个技能的抖动幅度建议在基准值的 5%–10% 之间。抖太大了连招会断，抖太小没意义。
时间轴表：一次改全部
连招步骤多的时候，把参数收进数组，用循环展开：
-- 下标从 0 开始（本设备数组与标准 Lua 不同）
local KEYS  = StringArray(6, 8)
local WAITS = Array(6)

KEYS[0] = "1"   WAITS[0] = 180
KEYS[1] = "2"   WAITS[1] = 220
KEYS[2] = "3"   WAITS[2] = 300
KEYS[3] = "q"   WAITS[3] = 400
KEYS[4] = "4"   WAITS[4] = 800
KEYS[5] = "5"   WAITS[5] = 500

for i = 0, 5 do
    KeyTap(KEYS[i])
    Delay(WAITS[i])
end

注意 StringArray(6, 8) 的第二个参数是单个字符串的容量，KEYS[i] 里放的是键名。数组长度声明之后不会自动扩容，写第 7 个就越界。
常见问题



现象
原因
处理




第二个技能没放出来
前摇/后摇比设的短，按键被吃掉
加 40–60ms 再试


连招到第三段就断
累计误差 + 游戏帧率波动
关键节点加长延时，不要全程卡极限


技能按了但没进 CD
目标/朝向/距离不满足
宏判断不了，只能靠站位固定


循环几轮后整体错位
某个技能实际 CD 比设的长
拿「最长那个」定循环周期，其余留空


长按型技能放不出来
KeyTap 只有 20ms
改用 KeyDown + Delay + KeyUp



最后一条值得单独说。有些技能是蓄力 / 长按触发的，KeyTap 的按下时长写死为 20ms（它就是 KeyDown → Delay(20) → KeyUp），这个时间不够，所以必须拆开自己写：
-- 蓄力 600ms 的技能
KeyDown("3")
Delay(600)
KeyUp("3")
Delay(150)

别指望它「智能」
宏不知道：

技能有没有进 CD；
目标在不在范围；
有没有被打断；
蓝量够不够。

它只会在设定的时刻按下设定的键。所以这类脚本的正确用法是：站好位置、确保资源充足、然后把时间轴跑一遍。跑的过程中出任何意外，它都会继续往下按——这就是必须有人看着的原因。
想做到「按情况调整」需要读游戏状态，那不是这套硬件的活。
]]></description><link>https://www.byteohm.com/topic/73/连招与技能循环的时间轴写法</link><guid isPermaLink="true">https://www.byteohm.com/topic/73/连招与技能循环的时间轴写法</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:13 GMT</pubDate></item><item><title><![CDATA[重复采集与刷素材的循环宏]]></title><description><![CDATA[单机游戏里最值得交给宏的是「节拍固定、路线固定」的重复劳动：走一段、交互、等动画、再走。这篇讲怎么写稳。

适用范围：仅单机 / 离线 / 自带训练场。不适用于任何联机对战模式。

分解成四段
任何一个采集循环都能拆成：
移动 → 交互 → 等待 → 回到起点

关键是每一段的时长都必须能从游戏里量出来，不能靠估。

移动：按住 W 从 A 走到 B 要多久？用秒表量三次，取最短的那个（会中途卡住的话取中位数）；
交互：E 按下去之后，采集动画多久结束？这段时间里按别的键会打断动画；
等待：动画结束后多久才能再次交互？早按了没反应，晚按了浪费时间；
回程：路线是闭环还是单向传送？

基础骨架
-- ===== 可调参数 =====
local ROUNDS     = 30      -- 循环轮数
local WALK_MS    = 1200    -- 前进时长
local INTERACT_MS = 900    -- 采集动画时长
local COOLDOWN_MS = 300    -- 动画结束到可以再次交互的间隔
local JITTER_MS   = 50     -- 随机抖动幅度
-- ====================

for i = 1, ROUNDS do
    -- 前进
    KeyDown("w")
    Delay(WALK_MS + math.random(-JITTER_MS, JITTER_MS))
    KeyUp("w")
    Delay(120)             -- 停稳，别在移动中就按 E

    -- 交互
    KeyTap("e")
    Delay(INTERACT_MS)

    -- 冷却
    Delay(COOLDOWN_MS)

    -- 回程（如果是闭环路线）
    KeyDown("s")
    Delay(WALK_MS + math.random(-JITTER_MS, JITTER_MS))
    KeyUp("s")
    Delay(120)
end

ReleaseAllKeys()

三处细节：

KeyUp("w") 之后那 120ms 不能省。角色停下来有减速过程，移动中按 E 可能不触发交互。
末尾 ReleaseAllKeys() 是兜底。万一中途按了终止键，w 会一直按着，角色会一直走。
每段移动都加抖动。固定周期的输入节奏太规律，某些游戏的风控会把完全等间隔的操作标记成异常（单机游戏也可能有在线反作弊组件）。抖动幅度不用大，±50ms 就够。

为什么要用变量而不是写死
游戏更新会改数值：地图拉长了、动画变快了、交互冷却调整了。参数提到开头，改一行就行：
local WALK_MS = 1400   -- 上次 1200，更新后地图变长了

如果时间写死在各处，改一次要找十几个地方，还容易漏。
加一个「中断检查」
长循环最怕的是「跑歪了还在继续跑」——角色卡在墙边，宏还在按 W，半小时后发现什么都没采到。
一个简单的自保机制是分段执行：不要一次跑 200 轮，跑 20 轮停一下，让眼睛看一眼。
local BATCH = 20
local BATCHES = 5

for b = 1, BATCHES do
    for i = 1, BATCH do
        -- 一轮采集
        KeyDown("w")
        Delay(1200)
        KeyUp("w")
        Delay(120)
        KeyTap("e")
        Delay(1200)
    end

    Delay(3000)            -- 每批之间停 3 秒，方便观察
    Log("batch %d done", b)
end

Log 在软件验证时能看到进度；烧进硬件后虽然看不到输出，但那段 Delay 仍然是「给自己看的一眼」。
常见问题



现象
原因
处理




采集没触发
移动中按了 E，或站的位置偏了
加停稳延时；检查路线是否需要修正


越跑越偏
每轮有微小误差，累积后偏离路线
减少单轮距离；或每 N 轮做一次「归位」动作


中途卡住不动
遇到障碍 / 怪物 / 加载界面
宏判断不了，只能靠人盯；缩短批次


第二次循环开始就乱了
动画时长比设的长
把 INTERACT_MS 加 20% 试


跑完后按键还按着
中途被中断，没执行到 KeyUp
末尾加 ReleaseAllKeys()；中断键随手能按到



别做的事

不要指望宏处理「意外」。掉线、加载、随机事件、怪物打断——它一个都处理不了。这就是为什么这类脚本必须有人看着。
不要用它绕过游戏的付费或进度设计。刷素材和刷货币是两件事，前者是省时间，后者可能违反游戏规则甚至用户协议。
不要在联机模式下开。单机游戏常常带联机功能，模式切错了性质就变了。

]]></description><link>https://www.byteohm.com/topic/72/重复采集与刷素材的循环宏</link><guid isPermaLink="true">https://www.byteohm.com/topic/72/重复采集与刷素材的循环宏</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:13 GMT</pubDate></item><item><title><![CDATA[单机游戏宏的边界：能做什么、不能做什么]]></title><description><![CDATA[先说结论：单机、离线、自带训练场的场景可以做，联机对战的一律不做。 这条线不是道德姿态，是两件不同的事。
为什么单机和联机是两回事
单机游戏里用宏，影响的是你自己的游戏体验。它和「开修改器」「用控制台刷材料」是同一类行为——加快你本来就要做的重复劳动，没有第二个玩家因此受损。很多单机游戏本身就内置了宏、脚本、自动化模组支持。
联机对战里用宏，影响的是同一局其他玩家的胜负。而且硬件盒子的输入由独立 HID 设备发出，反作弊读不到进程，它绕过的正是公平竞技赖以成立的那道检测。
同样是「按下键自动执行一串动作」，一件事只涉及你自己，一件事涉及不知道你存在的人。所以边界画在这里。
能做到什么
硬件盒子只做输出，不看屏幕、不读内存。所以它能做的是**「固定的动作序列」**：



能做
例子




固定路线的移动
按住 W 前进 1.2 秒，松开，按 E，等 0.9 秒，循环


重复采集 / 刷素材
同一套动作重复 50 次，中间加随机抖动


菜单导航
打开背包 → 切到第三页 → 选中 → 确认


技能循环
按固定顺序和固定间隔施放技能


训练场连招练习
把一套连招的时间轴固定下来，反复练手感


挂机式重复劳动
挖矿、钓鱼、跑商这类节拍固定的动作



做不到什么



做不到
为什么




看到敌人自动开枪
需要读画面或读内存，硬件没有这个通道


血量低了自动喝药
同上，判断不了血量


捡起指定物品
判断不了地上是什么


见招拆招
需要根据对方动作实时决策


自动寻路到指定坐标
只能按固定路线走，走歪了它不知道



任何声称「能看画面」的宏，要么是假的，要么跑在电脑上（读内存 / 截图分析），不是这套硬件。 别被这类说法带跑——买了硬件发现做不了，是你自己的损失。
适用范围声明怎么写
发单机游戏相关的脚本时，正文开头加上这一段，说清楚边界：
**适用范围**：仅单机 / 离线 / 自带训练场，不适用于任何联机对战模式。
**依赖**：固定路线或固定节拍。游戏更新导致地图、技能改动后可能需要重新调整。
**风险**：使用前请确认该游戏对自动化的态度；部分单机游戏也有反作弊，联机功能开启时请关闭宏。

第三行不是客套。现在很多单机游戏带在线模式（联机合作、排行榜、赛季），一旦在联机状态触发这类宏，性质就变了。玩之前先确认自己处在什么模式。
一个现实提醒
单机游戏宏的寿命通常比想象中短：

地图改了路线就废；
技能数值改了节奏就废；
动画时长调了，等待时间就不对。

所以写这类脚本的正确姿势是：把「时间」和「次数」全部提到开头当变量，游戏更新了只改顶部几行，不用重写逻辑。
-- ===== 可调参数 =====
local ROUNDS    = 30      -- 循环次数
local WALK_MS   = 1200    -- 每段前进时长
local COLLECT_MS = 900    -- 采集等待
local JITTER_MS = 60      -- 随机抖动幅度
-- ====================

最后
想拿联机游戏的方案来改？不用问了，这类脚本不发、不写、不讨论——包括改名、缩写、谐音、代号的形式。这条没有例外。
单机方向的具体写法，看这两篇：

《重复采集与刷素材的循环宏》
《连招与技能循环的时间轴写法》

]]></description><link>https://www.byteohm.com/topic/71/单机游戏宏的边界-能做什么-不能做什么</link><guid isPermaLink="true">https://www.byteohm.com/topic/71/单机游戏宏的边界-能做什么-不能做什么</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:13 GMT</pubDate></item><item><title><![CDATA[常见报错与处理]]></title><description><![CDATA[按出现阶段分四类：编译期、运行期、设备连接、软件崩溃。每类给现象、原因、处理。
一、编译期
编译只查语法，所以这一类的报错都指向「写法不合法」。



报错大意
原因
处理




意外符号 end / 缺少 end
容器块没闭合
数一下 if/while/for/function 各开了几个、end 有几个


未知函数 xxx
函数名拼错，或这个能力不存在
对着《内置函数与 HID 键码对照表》核名字。注意大小写：KeyDown 不是 keydown


参数数量不对
传多了或传少了
Delay 只要一个数；MoveMouse 要两个


字符串未闭合
引号少了一半
中文引号和英文引号不是一回事，必须用英文 "


期待 then
if 后面漏了 then
if x &gt; 1 then


期待 do
while / for 后面漏了 do
while x &lt; 5 do


无法解析的表达式
用了不支持的语法
常见：else if（应为 elseif）、!=（应为 ~=）、++（不存在）



一个高频错误：把 = 和 == 搞混。
if count = 5 then      -- 错，= 是赋值
if count == 5 then     -- 对，== 是比较

还有 ~= 是「不等于」，不是 !=。
二、运行期
这类不报错，只是行为不对。



现象
原因
处理




循环次数比预期多一轮 / 少一轮
数组下标从 0 开始，与标准 Lua 不同
检查 for i = 1, n 到底该到 n 还是 n-1


math.tointeger 结果总是 0
转换失败返回 0（不是 nil），看起来像「值就是 0」
用 math.type() 判类型


数值算出来差 1
// 是向下取整，负数时与直觉不同
-7 // 2 是 -4，不是 -3


拼接字符串编不过
没有字符串库
只能用 ..，没有 string.format


Log 输出错位
格式符与参数不匹配，或两种模式混用
首个参数有 %d/%s 就全按 printf 给


脚本跑到一半停了
按了终止键 / 触发了别的宏 / 目标程序弹了模态窗
见《编译通过但设备不动作》第 6、7 条



三、设备连接与加载



现象
原因
处理




一插设备软件就卡 / 加载超时
「自动加载宏」一次读入太多宏
拔设备 → 关自动加载 → 插回 → 烧录 → 清空所有绑定


状态栏第一栏一直是红的
线、口、Hub
换线、换口、直插


烧录后行为没变
只编译没烧录；或烧的不是当前场景
改一个明显参数重烧验证


软件里能连、系统里不认
USB ID 被改过
见《USB 协议自定义》


无线设备完全收不到输入
接收器没配对
见《无线接收器重绑与格式化》



四、软件崩溃
文档里点名的场景只有一个：自动加载宏 + 宏数量过多，表现为启动时崩溃或加载极慢。
处置流程（照文档原文的顺序）：

拔掉设备；
打开软件，把「自动加载宏」取消勾选；
插入设备；
点击烧录；
清空所有绑定的宏。

这套流程能恢复到干净状态。恢复后如果还崩，就不是宏数量的问题了，看下一节。
五、报错信息怎么贴
发帖求助时，不要只截一张报错图。需要三样：

报错原文（可以复制文字，比截图好）；
出错的那一段脚本，不是全部；
出错时代码在第几行（编译器一般会给行号）。

如果报错是「运行时才出现」（编译能过、运行崩），加上：触发方式、场景、目标软件、以及能不能用最小脚本复现。
最小复现脚本是排查里最有价值的东西——把问题从 200 行缩到 3 行，往往自己就看出原因了。
一个通用的降错顺序
写新脚本时按这个顺序推进，比写完一起调要快：

先写一行，编译 + 运行，确认环境通；
加第一段动作，跑，确认这一段对；
套循环，次数设成 2，跑；
次数改大，跑；
加条件，跑；
最后才烧进硬件。

每一步都只改一个变量。这样出问题时，原因一定是「刚改的那一处」。
]]></description><link>https://www.byteohm.com/topic/70/常见报错与处理</link><guid isPermaLink="true">https://www.byteohm.com/topic/70/常见报错与处理</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:12 GMT</pubDate></item><item><title><![CDATA[编译通过但设备不动作：排查清单]]></title><description><![CDATA[「编译没报错，脚本在软件里也能跑，烧进去按了没反应。」
这是最多的一类问题，而且几乎都不是代码问题。按下面五条顺序查，基本能定位。
第 0 步：先看状态栏第二栏
按一下触发键，看第二栏有没有变绿。

变绿 → 宏在跑。问题在「输出打到了哪里」或「动作本身不对」，跳到第 6 条；
不变绿 → 触发没进来。继续第 1 条。

这一步能砍掉一半的排查范围，别跳过。
第 1 条：设备类型选错了
宏绑定页的「设备类型」选的是插在盒子上的那个设备，不是你手上按的那个。

盒子插的是鼠标，这里选「键盘」→ 不生效；
盒子插的是键盘，这里选「鼠标」→ 不生效。

判断依据：触发键属于哪个设备。用鼠标侧键触发，就选鼠标；用键盘某个键触发，就选键盘。
第 2 条：触发键选错了

键盘支持全部 HID Usage 键。弹出列表后可以直接敲键盘快速选中——想绑哪个键就按一下它；
鼠标只支持五键（左、右、中、侧后、侧前）。

常见的错：想绑「侧键」，结果绑成了「中键」；想绑 F5，结果绑成了 num5（小键盘和主键盘不是同一个键）。
第 3 条：触发类型不适合这个脚本



脚本类型
该选




一次性动作（输入文本、执行快捷键序列）
按下触发


持续动作（连发、按住循环）
按下触发松开中断


松开才执行的动作
松开触发



最典型的错：连发脚本 while true do ... end 绑了「按下触发」。这时脚本会一直跑下去，松手也不停（只能按终止键），用户会以为「卡住了」。反过来，一次性脚本绑了「按下触发松开中断」，手指一松就中断，动作只做了一半——也会被描述成「不动作」。
第 4 条：场景不对
10 个场景互相独立。你在场景 1 配的宏，切到场景 3 之后完全不生效。
看当前是哪个场景，以及场景切换快捷键有没有被误触。这是「昨天能用今天不能用」的最高频原因。
第 5 条：到底烧录成功了没
三种常见情况：

只编译没烧录。改完脚本 → 编译 → 就以为生效了。必须点宏绑定页的烧录，硬件里跑的是烧进去的那一版；
烧录时设备没连好。状态栏第一栏是红的，烧录不会成功；
烧的是另一个场景的配置。烧录是对当前场景生效的。

判断方法：改脚本里一个明显的参数（比如把连点次数从 10 改成 3），重新编译 + 烧录，看行为有没有变。没变说明烧录这一步没成功。
第 6 条：状态栏绿了但没效果
说明宏在执行，但按键没打到该去的地方，或者动作本身不是你想要的。



现象
原因




按键没反应，鼠标也没动
目标窗口没有焦点。宏只发按键，不切窗口


文字进去了，但全是数字 / 乱码
TypeText 的小键盘被 NumLock 关掉了，或输入法在中文状态


按键变成了别的功能
目标软件改过快捷键；或者用了小键盘键而软件只认主键盘键


动作做了一半就停
延时给少了，后续动作被前一步的未完成状态吞掉


触发了两次
触发键被宏自己按到了（自我触发），换一个不冲突的键



第 7 条：终止键的问题
默认终止键是 ESC。如果你插的是小键盘或者只用鼠标，ESC 可能根本按不到——脚本跑起来之后停不下来，表现是「一直动」。
去 偏好 → 宏中止按键，换一个手边有的键。写 while true 循环之前，这一步必须做。
还没解决
按这个顺序再试一遍：

重启软件，重新插设备。排除状态问题；
换一个最简单的脚本（就一行 KeyTap("a")）烧进去试。能用 → 问题在原脚本；不能用 → 问题在设备或绑定；
关闭自动加载宏，清空所有绑定，从头加一个宏。排除历史配置污染（见《设备识别、固件更新与恢复》）；
换一个 USB 口直插，不经 Hub。

到这里还不行，去发帖，把这五项写全：
软件版本 / 固件版本：
设备类型：键盘 or 鼠标
触发键 + 触发类型：
场景编号：
脚本原文 + 编译输出：
现象：第二栏变绿吗？目标窗口是什么软件？

这五项写全，问题基本一眼能看出来。只写「不能用」的帖子，谁也帮不上。
]]></description><link>https://www.byteohm.com/topic/69/编译通过但设备不动作-排查清单</link><guid isPermaLink="true">https://www.byteohm.com/topic/69/编译通过但设备不动作-排查清单</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:12 GMT</pubDate></item><item><title><![CDATA[无线接收器重绑与格式化]]></title><description><![CDATA[无线版有两个和有线版不一样的入口：重新绑定接收器和格式化接收器固件。前者是日常维护，后者是危险操作。这篇把两者分清。
重新绑定接收器：什么时候用
两个场景：

接收器换了新的（丢了、坏了、补发了），新接收器和设备之间没有配对记录；
接收器的绑定信息被清除了（比如误操作、异常断电、固件被重刷）。

现象是：设备能开机，但电脑上完全收不到输入——因为接收器不认识这台设备。
操作：偏好 → 无线配对 → 重新绑定接收器。按提示把设备和接收器靠近，等配对完成。
这一步是可逆的、安全的。配错了再配一次就行，不会损坏任何东西。
格式化接收器固件：这不是随时能做的
这个入口是为「需要给接收器烧录新固件」准备的——正常使用完全用不到。
文档里的原话需要完整读一遍：

需要烧录新的接收器固件时点击此项；如果烧录的固件有问题导致接收器变砖时，需要使用专用的烧录器才可能会恢复，如果之前烧录时选择的不是 PB11 则无法恢复。

拆开看，这句话里有三个信息：

它是给接收器换固件用的，不是修复工具；
烧坏了会变砖，软件层面救不回来，需要专用烧录器，而且只是「可能」恢复；
前提条件是有条件的——如果烧录时选的引脚不是 PB11，无法恢复。

第 3 条是最要命的：它不是「变砖后还能救」，而是「只有当初选对了引脚的那一批才有救」。
所以，动它之前
如果你不是明确要烧接收器固件（比如官方给了新固件包并说明了流程），不要点这个按钮。
真要动，按这个顺序准备：

确认固件包是为这个接收器型号做的。型号对不上，刷进去就是变砖；
确认引脚选择。文档只提到 PB11 是可恢复的那一档，其他引脚刷坏了没有救；
保证供电稳定。刷写过程中断电是变砖的最主要原因，不要用快没电的笔记本、不要插在会松动的 Hub 上；
不要同时在跑别的宏或烧录。刷写期间设备被别的操作打断，结果不可预期；
刷完立刻验证：能不能连上、按键有没有反应。

如果这五条里有任何一条你没法确认，就先别刷。
变砖了怎么办
现象：接收器插上后系统毫无反应，或者设备管理器里出现未知设备。
处理顺序：

换 USB 口、换线，先排除接触问题（这一步能解决相当一部分「以为变砖」）；
在另一台电脑上试一次，排除本机驱动问题；
都不行，联系支持，说明：接收器型号、刷的是哪个固件、当时选的哪个引脚、卡在哪一步。这四项决定还有没有救；
如果当初选的不是 PB11，按文档说法是无法恢复，只能换接收器。

和有线的区别



项
有线
无线




配对
不需要
需要，接收器与设备一一对应


换接收器
不涉及
必须重新绑定


刷固件风险
设备端固件，风险较低
接收器变砖可能不可恢复


排查第一步
换线换口
换线换口 + 确认配对



日常维护建议

配对信息不要随便清。它不是「重置一下更干净」的东西，清了就得重配；
接收器单独存放。丢了接收器等于设备不能用，而重新配一个接收器比想象中麻烦；
不要为了「试试看」点格式化。这个按钮的代价不对称：点对了没收益，点错了可能报废一台设备。

]]></description><link>https://www.byteohm.com/topic/68/无线接收器重绑与格式化</link><guid isPermaLink="true">https://www.byteohm.com/topic/68/无线接收器重绑与格式化</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:12 GMT</pubDate></item><item><title><![CDATA[USB 协议自定义：VID/PID 与字符串描述符]]></title><description><![CDATA[设备在系统里是怎么被认出来的？靠四个 ID 和三个字符串。偏好里的「USB 协议配置」就是改这些的地方。
四个 ID 和三个字符串



项
含义
例子




Vid
Vendor ID，厂商 ID
0x0483（ST 的厂商号）


Pid
Product ID，产品 ID
0x5710


Manufacture
厂商字符串，设备管理器里显示
My Devices


Product
产品字符串
KMA Box


Serial
序列号字符串
KM-0001



操作系统靠 Vid + Pid 决定加载哪个驱动（或者不加载）。字符串只是给人看的。
改了有什么用
1. 和真实设备区分开。 如果盒子和你的真鼠标用了同一组 Vid/Pid，系统里会出现两个同名设备，某些软件（尤其游戏和宏软件）会认错。改成不同的值就不会混。
2. 让特定软件识别成它能认的设备。 少数软件按 Vid/Pid 白名单判断「这是不是支持的硬件」。改成白名单里的值，它才认。
3. 多台设备共存时区分。 两个同样的盒子插在同一台机器上，用 Serial 区分。
改了会有什么后果
必须说在前面：这四个值是设备对外的身份，改错了会出问题，而且改了之后系统里的记录会和之前不一致。
常见后果：



后果
原因




改完系统认不出设备，软件也找不到
Vid/Pid 组合没有对应的驱动匹配，或与其他设备冲突


设备管理器里出现感叹号 / 未知设备
同上


你需要拔插好几次才认到
系统缓存了旧的设备实例


改之前能用的软件，改之后不认了
那个软件按 ID 做了白名单



操作前记下原始值。 截图或者手抄：Vid、Pid、Manufacture、Product、Serial 五项。改了之后如果出问题，还能改回来。
如果改完之后软件彻底找不到设备、连改回来的入口都进不去——这时候需要按「清空所有绑定的宏」那套流程重置（见《设备识别、固件更新与恢复》），或者重新烧录固件。
一个稳妥的改法
不要一次改五项。按这个顺序：

先只改 Product 字符串（纯展示，风险最低）。改完拔插，看设备管理器里的名字变了没。确认这套流程能走通。
再改 Manufacture。
最后才考虑动 Vid/Pid——这两个才是有真实后果的。

改 Vid/Pid 时不要选这几类值：

系统关键设备的 ID（键盘、鼠标、存储控制器，比如 0x046D 罗技、0x045E 微软的常见值）；
你机器上已有的其他设备的 ID（会撞）；
0x0000 这类明显非法的值。

只改 Serial 的一个用途
多台设备插同一台机器时，操作系统通过 Serial 区分实例。如果两个设备的 Vid/Pid 相同、Serial 也相同，系统会认为是同一台设备反复插拔，配置可能互相覆盖。
给每台设备一个不同的 Serial 就解决了。这是这五项里唯一「改了几乎不会有副作用」的一项（前提是别和其他设备重复）。
什么时候不用管它
绝大多数用户不需要动这一页。
如果你的设备在系统里正常识别、软件正常连接、宏正常烧录，那就保持默认。这不是一个「优化项」，是一个「出问题时才用的开关」。 改它的收益很小，代价是可能把一台好设备弄成需要重置的状态。
排查：改完不认了

拔掉设备，等 5 秒，插回；
看设备管理器里有没有新出现的未知设备 / 带感叹号的设备；
如果有，说明 ID 生效了但驱动没匹配上——把 Vid/Pid 改回原值；
如果软件连「关于」页都读不到设备信息，走重置流程：拔设备 → 开软件 → 关闭自动加载宏 → 插设备 → 烧录 → 清空绑定；
以上都不行，联系支持时把原始 ID 和改成的 ID 一起报上去，这比描述现象有用得多。

]]></description><link>https://www.byteohm.com/topic/67/usb-协议自定义-vid-pid-与字符串描述符</link><guid isPermaLink="true">https://www.byteohm.com/topic/67/usb-协议自定义-vid-pid-与字符串描述符</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:11 GMT</pubDate></item><item><title><![CDATA[设备识别、固件更新与恢复]]></title><description><![CDATA[设备出问题时，第一件该做的事是把版本信息记下来。这篇讲怎么查、怎么更新、以及出事了怎么救回来。
先看关于页
关于页有三样东西：



项
用途




软件版本
求助帖必须写


固件版本
与软件版本可能不同步，升级时要分别看


设备标识号
右键可复制，是这台设备的唯一标识



设备标识号一定要先复制存下来。 后面所有需要「证明这是同一台设备」的场合（保修、找客服、恢复配置）都用得上，而它只在这一页显示。
状态栏三个灯的意义



栏位
含义




第一栏
连接状态。红 = 没连上，绿 = 已连接


第二栏
运行状态。红 = 当前没在跑宏，绿 = 宏正在执行


第三栏
实时消息



排查「宏不动作」时，第二栏是最直接的判据：按了触发键，第二栏有没有变绿。

变绿但没效果 → 宏在跑，但按键打到了别的地方（焦点问题）或者动作本身不合预期；
不变绿 → 触发根本没进来（触发键 / 触发类型 / 场景 / 设备类型的问题）。

这一条能把问题范围砍掉一半。
检查更新
关于 → 检查更新，会去服务器看有没有新的软件或固件。
升级前建议：

先做一次配置导出（偏好 → 配置 → 导出）。它会把 config 目录打包备份，出问题能导回来；
记下当前版本号；
升级完成后重新插一次设备。

导出这一步不要省。 导入会覆盖当前配置，所以顺序是「先导出再动」，不是「动坏了再导出」。
自动加载宏：省事但会出事
偏好里有个「自动加载宏」：软件启动时自动把宏读进来。日常用很方便，但宏数量多了会卡。
文档里明确写了处理办法，照做即可：

拔掉设备；
进偏好，把「自动加载宏」取消勾选；
插回设备；
点烧录；
清空所有绑定的宏。

这样能恢复到「设备里没有宏」的干净状态。之后再一项项加回去，加到卡为止就知道是数量问题。
什么时候该关掉它：宏列表很长（几十个以上）、软件启动明显变慢、或者一插设备就崩溃。日常用不到自动加载的话，关着更稳。
烧录失败怎么看
烧录是「把配置写进硬件」这一步。它失败时通常表现为：状态栏没有成功提示、重新插拔后宏还在旧状态。
按这个顺序查：

设备连接是否正常（第一栏是不是绿的）；
是不是还在上一个宏的编辑状态——先编译通过再烧录；
换一个 USB 口 / 换一根线。供电不足和数据线劣质是烧录失败的高频原因，尤其经过 Hub 的时候；
拔掉 Hub，直插。文档提到支持 2.0 USB 集线器同时插键盘和鼠标，但烧录阶段直插更稳；
还不行就按上一节的「清空所有绑定的宏」走一遍，从空状态重新加。

关于固件回退
需要说清楚：设备端固件没有官方文档化的回退流程。
手上有旧版软件安装包时，装回旧版是可行的（卸载当前版本再装旧的）。但固件不是——固件是烧进设备的，降级需要对应版本的固件包和对应的烧录方式，这一步文档没有覆盖。
所以对固件的原则是：没有明确需要，不要动。 升级前确认当前版本能用、配置已导出，升级后立刻验证基本功能（连点、按键）是否正常，别等做完一整套宏才发现设备不对。
一张排查顺序表



现象
先看这里




第一栏是红的
线、口、Hub。换线换口先试


第一栏绿、第二栏不绿
触发键 / 触发类型 / 场景 / 设备类型


第二栏绿但没效果
焦点在不在目标窗口；输入法状态


烧录后行为没变
是否真的烧录成功；是否改完只编译没烧录


一插就崩溃
关掉「自动加载宏」，清空绑定后重来



]]></description><link>https://www.byteohm.com/topic/66/设备识别-固件更新与恢复</link><guid isPermaLink="true">https://www.byteohm.com/topic/66/设备识别-固件更新与恢复</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:11 GMT</pubDate></item><item><title><![CDATA[块编辑器的操作细节]]></title><description><![CDATA[入门那篇讲了怎么拼出一个宏。这篇是操作层面的清单：移动、复制、撤销、缩放、条件追加——都是实际用起来才发现「原来还能这样」的东西。
移动
直接拖动块。

拖到别的块之间 = 改变顺序；
拖进容器块的嘴里 = 移进循环 / 条件内部；
拖动过程中按 Esc 放弃本次移动，块会回到原位。

最后这条很实用：拖歪了不用松手再找回来，按 Esc 就复位。
多选
按住 Ctrl 单击块，逐个加选 / 减选。选中的块带琥珀色边框。
多选之后可以一次性删除（Delete）、一次性复制（Ctrl+C）。批量调结构时比一个个拖快得多。
复制粘贴

Ctrl+C / Ctrl+V
右键菜单同样有

复制的是整棵块树——含子语句与多分支条件，不是只复制眼前这一行。所以可以把一个完整的循环结构连同里面所有东西一起搬到另一个脚本里。
从别处复制来的纯文本粘贴进画布时，会尝试解析成块。解析不了的部分会以注释块或纯文本形式落地，不会丢内容。
创建副本
右键 →「创建副本」，原地复制一份插在后面。和剪贴板互不影响——你剪贴板里的东西不会被覆盖。
改一个块的参数做微调时，这个比「复制 + 粘贴」顺手。
删除
选中后按 Delete 或 Backspace。多选时一次删掉全部。
注意：选中值块时只删这一块；选中语句块时删整条（含嘴里所有子语句）。删语句块前先看清选中的颜色范围。
上移 / 下移
右键菜单，同级内调整一条语句的位置。拖拽也能做到，但在密集的块链里拖容易放错位置，用菜单更准。
条件分支的追加
在「条件分支」块上右键：

添加「否则如果」分支 / 删除最后一个「否则如果」分支
添加或删除「否则」分支（同一项在添加 / 删除之间切换）

一个 if 想加第三个分支，不用重新拼，右键加一个就行。
缩放：40% ~ 300%

右下角比例按钮：显示当前比例（如 100%），单击弹出「放大 / 缩小 / 实际大小 / 适应宽度」；
Ctrl + 滚轮：以鼠标所在位置为中心缩放，缩放时光标下的块不会跑掉；
Ctrl + = 放大、Ctrl + - 缩小、Ctrl + 0 回到 100%；
适应宽度：把整棵块树横向塞进窗口。代码写得宽（多层条件嵌套）时用它一屏看全。

不按 Ctrl 的滚轮就是正常的上下滚动。
撤销与重做

Ctrl+Z 撤销
Ctrl+Shift+Z 或 Ctrl+Y 重做
右键菜单顶部也有，灰色表示没有可回退的操作

能回退的包括：改参数、删块、拖错位置、加分支。所以拖歪了不用怕，撤一下就行。
定位选中
右栏顶部有个「定位选中」开关。打开后，在画布中点选一个块，右侧目录会自动滚动并高亮到对应条目。
脚本里用了十几个不同类型的块时，这个开关能帮你快速找到「这个块对应目录里的哪一项」，反过来也能从目录定位到画布上的块。不需要自动滚屏就关掉它。
快捷键一览



操作
快捷键




复制 / 粘贴选中块
Ctrl+C / Ctrl+V


删除选中块
Delete 或 Backspace


加选 / 减选
Ctrl+ 单击


撤销 / 重做
Ctrl+Z / Ctrl+Shift+Z（或 Ctrl+Y）


放大 / 缩小 / 实际大小
Ctrl+= / Ctrl+- / Ctrl+0


以光标为中心缩放
Ctrl+ 滚轮


放弃当前拖动
Esc



画布右键菜单



菜单项
说明




撤销 / 重做
与快捷键等价，空白处右键也能用


复制 / 粘贴
空白处右键时粘贴追加到末尾


缩放 ▸
放大 / 缩小 / 实际大小 / 适应宽度


创建副本
原地复制插在后面


删除
选中值块删这一块，选中语句块删整条


上移 / 下移
同级内调顺序


添加 / 删除分支
仅「条件分支」块上有


编辑这段表达式…
条件 / 数值槽上右键，用手写表达式整段替换


这是什么？
弹出这个块的用途说明



与文本模式的关系
三种模式共用同一份脚本：图形模式里每改一次块，就同步生成等价的 Script 文本，编译、验证、保存、烧录都走同一条链路。
从图形切回文本时，看到的就是即将运行的文本。块编辑器会做一次规范化排版（缩进、括号、空白），语义不变但换行位置可能与你手写的不同——这是正常现象，不是内容被改动了。
反过来，从文本切到图形时，如果遇到暂不支持的写法会拒绝切换并指出行号，脚本内容不受影响。
]]></description><link>https://www.byteohm.com/topic/65/块编辑器的操作细节</link><guid isPermaLink="true">https://www.byteohm.com/topic/65/块编辑器的操作细节</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:11 GMT</pubDate></item><item><title><![CDATA[图形化块编程入门]]></title><description><![CDATA[不想写代码也能做宏。图形模式把脚本拆成一块一块，拖着拼起来就行，拼完照样编译、烧录。
先讲清一件事：图形模式和文本模式是同一份脚本的两种看法。 不是两套东西，也不是「简单版」和「专业版」。你在图形里拖一个块，文本里就多一行；你在文本里改一行，切回图形看到的就是改过的样子。随时可以来回切。
怎么切过去
宏编辑页工具栏最右端是编辑形态开关：

左段 &lt;/&gt; → 文本模式
右段（叠块图标）→ 图形模式

点一下右段就切。软件会记住你上次用的形态，下次打开同一个宏自动恢复。
工具栏左侧的编译和验证两个按钮对两种模式都管用，切到图形模式后不用回文本模式就能检查。

如果当前脚本里有图形模式暂时不支持的写法，切换会被拒绝——脚本内容不会改动，下方输出窗口会说明是哪一行无法转换成语句块。这种情况继续用文本模式编辑就行，不影响使用。

界面



区域
图形模式下的内容




左栏
宏目录，和文本模式相同，选要编辑的宏


中栏
块画布。整段宏就是一条从上往下咬合的块链


右栏
块目录，按功能分组，可搜索



容器块（条件、循环、子程序）带一个「嘴部」，子语句落在嘴里——也就是缩进在它内部。
右栏共 8 组：



分组
内容




控制语句
条件分支、当型循环、计数循环、跳出循环、注释


条件与运算
且、或、非、比较、四则运算


数学
math.round / math.abs / math.random / math.tointeger / math.type


变量与数据
声明变量、变量赋值、数组、字符串变量、字符串数组


子程序
定义子程序、返回


键盘
KeyDown / KeyUp / KeyTap / ReleaseAllKeys / IsKeyDown / IsLockKeyOn


鼠标与坐标
MouseDown / MouseUp / MouseClick / IsMouseDown / MoveMouse / MoveMouseBy / ScrollMouse / TouchScreen / ScreenSize


延时与输出
Delay / Log / TypeText / GetUpTime



后续版本新增的命令如果还没归类，会出现在最后的「其他命令」组里，不会找不到。
三种放入方式

拖拽：从右栏拖到画布，落点出现插入线，松手插入到那个位置。拖到容器块的「嘴里」就是放进循环 / 条件内部。
单击：插入到当前选中块的后面；画布上没有选中块时追加到末尾。
返回值函数：IsKeyDown、GetUpTime、math.* 这些不是独立语句，放入后会自动生成一个 result = 函数(...) 的赋值块，光标停在括号里。把左边的变量名改成你要的即可。

改块上的内容



元素
操作




白色字段
单击进入编辑，回车确认，Esc 取消


带下拉箭头的字段
单击弹出候选（存储类型、循环步长、运算符等）


块尾的 + / x
增加一个参数槽 / 去掉最后一个。键盘、鼠标、Log 最多 16 个参数


数组下标小开关
打开后可以填序号，操作数组元素



值块不能单独成句
「条件与运算」和「数学」两组是值块：它们本身不产生动作，只产生一个值。所以不能直接放在语句链上，必须拖进条件槽或数值槽里。
比如「条件且」拖到已经写好的条件上，会用「且」把两个条件连起来——这就是加第二个条件的做法。想给整个条件取反，用「条件非」。
条件槽里的胶囊块可以直接单击中间的运算符切换：

比较块：等于 / 不等于 / 小于 / 小于等于 / 大于 / 大于等于
四则块：加 / 减 / 乘 / 除以 / 整除 / 取余

想整段换成手写表达式：在条件上右键 →「编辑这段表达式…」。
完整例子：连点 10 次、每次间隔 50ms

从右栏拖入「计数循环」，块面默认是 i = 1 到 10，保持不动；
从「鼠标与坐标」组把「MouseClick」拖进循环的嘴里；
单击块上的按钮参数，改成 1（左键）；
再从「延时与输出」组拖一个「Delay」进嘴里，填 50；
点工具栏编译检查语法，再点验证试跑。

切回文本模式，看到的就是：
for i = 1, 10 do
    MouseClick(1)
    Delay(50)
end

加个条件：按住才连点
想让它「按住某个键时才继续」，需要条件分支 + 值块：

拖入「当型循环」，默认条件是 true；
从「键盘」组拖「IsKeyDown」到画布，它生成 result = IsKeyDown(...)——删掉这一句，改用另一种方式：直接把「条件与运算」里的比较块拖到循环的条件槽里；
比较块左边的槽填 IsKeyDown("lshift")（右键「编辑这段表达式」可以直接写），运算符选「等于」，右边填 true；
循环嘴里放 MouseClick 和 Delay。

对应的文本：
while IsKeyDown("lshift") == true do
    MouseClick(1)
    Delay(50)
end

这种写法不需要 ESC 兜底，条件不成立自己就退出了——比 while true 安全。
什么时候该切回文本

脚本里出现图形模式不支持的写法（切换会被拒绝，会告诉你哪一行）；
需要精调表达式（右键「编辑这段表达式」也能写，但长的还是文本模式舒服）；
从别处拷来的脚本想先看一眼再改。

两边改的是同一份东西，不存在「图形模式下写的不算数」这种问题。
]]></description><link>https://www.byteohm.com/topic/64/图形化块编程入门</link><guid isPermaLink="true">https://www.byteohm.com/topic/64/图形化块编程入门</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:10 GMT</pubDate></item><item><title><![CDATA[调试三件套：编译、验证、Log]]></title><description><![CDATA[宏编辑器里只有三个调试手段：编译、运行（验证）、Log。用好这三个，大部分问题不用猜。
编译：只查语法，不执行
工具栏第一个按钮。它做的事就一件：把脚本解析成语法树，看能不能过。

过了 → 不代表逻辑对，只代表写得出合法语句；
没过 → 输出窗口会指向出错的行。

编译阶段能发现的：括号不配对、end 少了、for 后面漏 do、用了不存在的函数名、字符串引号没闭合。
编译阶段发现不了的：变量算错、延时给少了、按键绑定错了、目标程序没响应。
常见报错与含义：



报错大意
大概率原因




意外的 end / 缺少 end
容器块（if / while / for / function）嵌套没闭合


意外的符号 xxx
用了不支持的语法，比如 elseif 写成了 else if


未知函数 xxx
函数名拼错，或者这个能力本设备不支持


字符串未闭合
引号少了一半，或者字符串里有引号没转义



验证：真执行，但是在电脑上
工具栏第二个按钮（运行Lua脚本）。它会真的执行：鼠标会动，键会按。
用途是验证流程对不对，但有三件事必须清楚：

它在电脑上跑，不是盒子。软件侧是解释执行，硬件侧是编译成字节码后在设备上跑。链路不同，时序表现可能不一样。
执行前把光标放到安全位置。它是真的在点，点在什么地方就是什么地方。
验证通过 ≠ 硬件可用。这是最常见的误判来源：软件里跑得好好的，烧进去不动。

Log：唯一能看到内部状态的东西
Log("count=%d", count)
Log("name=%s", name)
Log("hello", 1, "world")      -- 没有格式符时按空格分隔

规则：首个参数含 %d / %s / %f 等格式符时按 printf 走，否则按空格分隔打印。两种模式别混用：
Log("count=%d and", count, "more")   -- 容易错位，别这么写

类型要对应：%d 对整数、%s 对字符串、%g 对浮点。cost / 100 是浮点，用 %d 会打出奇怪的值。
输出在编辑器下方的输出窗口 / 状态栏第三栏，软件验证时可见。
一套实际的定位流程
脚本「有动作但结果不对」时，按这个顺序切：
第一步：缩小到最小可复现脚本。
把出问题的那一段单独剪出来，前面加上必要的初始状态，跑一遍。能复现，问题就在这段里。
第二步：二分注释。
一段 20 行的脚本，把后 10 行注释掉（--），跑。看前半段是不是对的。对 → 问题在后半段；不对 → 问题在前半段。重复三次就能锁定到 2–3 行。
第三步：在关键位置插 Log 看状态。
local count = 0
while count &lt; 5 do
    Log("loop start count=%d", count)
    MouseClick(1)
    Delay(50)
    count = count + 1
    Log("loop end count=%d", count)
end

如果 Log 打出来的次数不对，问题在循环条件；如果次数对但动作不对，问题在循环体。
第四步：区分「代码问题」和「环境问题」。
在脚本里加一行固定的动作，比如开头先 KeyTap("a")：

如果连这个固定动作都没执行 → 代码根本没跑起来（触发方式、场景、烧录）；
如果这个动作执行了，后面的没有 → 代码问题或者延时不够。

几个反复出现的坑
Log 打不出东西。 先确认是在软件里验证，不是在硬件上跑。硬件端没有输出窗口。
脚本执行到一半停了。 检查是不是按了终止键（默认 ESC），或者中途触发了别的宏。也可能是目标程序弹了模态窗口把输入吞了。
同样的脚本，今天能跑明天不能。 检查场景是不是被切走了；或者绑定的触发键被别的软件占用了。
改了脚本但行为没变。 改完要重新编译、重新烧录。只编译不烧录，硬件里跑的还是旧版本——这是最高频的「明明改了却没生效」。
]]></description><link>https://www.byteohm.com/topic/63/调试三件套-编译-验证-log</link><guid isPermaLink="true">https://www.byteohm.com/topic/63/调试三件套-编译-验证-log</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:10 GMT</pubDate></item><item><title><![CDATA[延时精度与宏时长预算]]></title><description><![CDATA[「延时误差小于 1ms」这句话经常被误读成「这个宏的时间是精确的」。这两件事差得远。这篇把时间到底花在哪算清楚。
单次精度不等于整体精度
Delay(50) 的真实含义是：这一条延时指令执行 50ms，单次误差小于 1ms。
但一个宏的时间里还有别的东西：
宏总时长 = Σ Delay 值
         + Σ 命令固有耗时（KeyTap / MouseClick 内部各含一条 Delay(20)）
         + Σ 单次误差（每条 &lt;1ms，会累积）
         + 通讯与调度开销（设备端执行，微秒级，可忽略）

「命令固有耗时」这个说法容易让人以为是额外开销，其实它就是一条 Delay：KeyTap(k) 展开为 KeyDown(k) → Delay(20) → KeyUp(k)，那 20ms 是写死在里面的延时；MouseClick 同理。所以它能被算进 Σ Delay 值，只是这条延时不是你写的、也改不了。要别的间隔就别用 KeyTap，自己写成三段式。
一段 100 次的连点，每次 MouseClick + Delay(30)：



项
计算
结果




Delay 总和
100 × 30
3000ms


点击固有
100 × 20
2000ms


累积误差
200 条指令 × &lt;1ms
最多 200ms


总计

约 5.2 秒



你以为写的是 3 秒，实际 5.2 秒。差的 2.2 秒全在 MouseClick 里——那 20ms 是写死在命令里的，改不了。
什么时候累积误差会咬人
单条 &lt;1ms 听起来没问题，但它是每条指令的误差，不是整个脚本的。

10 条指令：最多 10ms，感觉不出来；
200 条指令：最多 200ms，在「按键要跟手」的场景里已经能被察觉；
2000 条指令（比如 TypeText 输入长文本）：误差可以到秒级。

所以：长宏不要指望靠精确延时对齐外部事件。真要同步，靠目标软件的反馈（比如等窗口出现再继续），而不是靠算时间。
预算表：给多少算够
按「目标软件多久能处理完上一个动作」来给，不按按键响应给：



场景
建议
说明




同软件内连按
30–60ms
界面一帧（16ms）加余量


跨软件切窗口
200–300ms
窗口激活 + 重绘


等待弹窗出现
300–500ms
窗口渲染不可控


复制 / 粘贴
100–150ms
剪贴板异步


打开文件 / 导出
800ms 起
磁盘 IO


网页加载完再输入
1500ms 起
网络不可控



宁可多给。 多给 50ms 人感觉不出来；少给 20ms 就可能把动作打到上一个状态上，产生难以回退的结果（比如删错内容）。
用 GetUpTime() 实测
不要猜，量一下：
local start = GetUpTime()

local count = 0
while count &lt; 100 do
    MouseClick(1)
    Delay(30)
    count = count + 1
end

local cost = GetUpTime() - start
Log("100 次耗时 %d ms，平均 %.1f ms/次", cost, cost / 100)

Log 的 %d 对 64 位整数有效；cost / 100 是浮点除法，用 %.1f 保留一位小数。
在软件里点「运行Lua脚本」，输出窗口会打出真实数字。如果实测比预算多出一大截，说明中间某条命令比你以为的慢——通常是目标程序在忙。
硬件端与软件端的差异
GetUpTime() 在两个环境里含义不同：

编辑器里验证时：从本次校验开始计时；
烧录后在硬件上跑：从设备开机起计时。

所以脚本里如果直接用 GetUpTime() 的绝对值做判断（比如「超过 5000 就停」），在硬件上会立刻成立——因为设备可能已经开机好几分钟了。只能用它算差值，不能用来算绝对值。
手感调优的经验
调到「手感对」通常不是把延时压到最小，而是找到那个「不丢动作的最小值」：

先给足（比如全部 150ms），确认动作全部正确；
每次减 20ms，跑 10 遍，看有没有丢；
出现丢动作就回退一档，定为最终值；
换个机器或换个软件版本重测——同一套延时在不同机器上结论会变。

最后一条很重要：宏的时间参数和机器性能绑定。给别人分享脚本时，把延时写成开头的变量，注明「在我的机器上这个值够用，你的机器可能需要加」。
]]></description><link>https://www.byteohm.com/topic/62/延时精度与宏时长预算</link><guid isPermaLink="true">https://www.byteohm.com/topic/62/延时精度与宏时长预算</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:10 GMT</pubDate></item><item><title><![CDATA[内置函数与 HID 键码对照表]]></title><description><![CDATA[这套脚本的全部能力就是下面两张表：15 条命令 + 9 个函数。没有别的。想确认某个操作能不能做，先在这两张表里找；找不到就是做不到，网上的教程再花哨也没用。
一、键鼠命令



命令
参数
说明




KeyDown(key, ...)
HID Usage 整型或按键名，最多 16 个
按下按键。多个参数表示同时按下，可组成组合键


KeyUp(key, ...)
同上
松开按键


KeyTap(key, ...)
同上
点击按键 = KeyDown + Delay(20) + KeyUp，参数逐个串行


ReleaseAllKeys()
无
释放所有键盘按键


MouseDown(button)
1 左 / 2 右 / 3 中 / 4 侧后 / 5 侧前
按下鼠标键


MouseUp(button)
同上
松开鼠标键


MouseClick(button)
同上
点击，按下与松开间隔 20ms


MoveMouse(x, y)
整型坐标
移到屏幕绝对坐标，配合 ScreenSize 使用


MoveMouseBy(x, y)
整型增量
相对当前位置移动


ScrollMouse(click)
-128 ~ 127
滚轮，正数向上、负数向下


TouchScreen(is_touched, x, y)
0/1, x, y
触摸屏按下 / 松开，坐标配合 ScreenSize




KeyTap 和 MouseClick 里的 20ms 不是隐藏参数，就是它们内部那条 Delay(20)：
KeyTap(k) = KeyDown(k) → Delay(20) → KeyUp(k)，MouseClick(b) = MouseDown(b) → Delay(20) → MouseUp(b)。
所以想要别的间隔，别去调这两个命令，直接用三段式写，Delay 填多少就是多少。
另外 KeyTap 多个参数是逐个按下-松开，不是同时按下。

二、延时与其他



命令
参数
说明




Delay(ms)
整型，毫秒
延时，误差小于 1ms


Log(arg, ...)
任意类型，最多 16 个
首个参数含 %d/%s/%f 时按 printf 格式化，否则空格分隔输出


ScreenSize(w, h)
整型宽高
声明脚本参照分辨率，默认 1920×1080


TypeText(text, mode)
字符串；gbk / unicode
输入文本，编译期展开为按键序列



三、状态查询与数学



函数
参数
返回




IsKeyDown(key)
HID Usage 或键名
该键当前是否按下


IsMouseDown(button)
1–5
该鼠标键当前是否按下


IsLockKeyOn(key)
"capslock" / "numlock" / "scrolllock"
锁定键是否亮着


GetUpTime()
无
运行时长（毫秒，64 位）。设备端为开机以来，编辑器里为本次校验以来


math.type(v)
任意
"integer" 或 "float"


math.tointeger(v)
浮点
恰为整数时转成整数，否则返回 0（不是 nil）


math.round(v)
整数或浮点
四舍五入，.5 远离零取整


math.abs(v)
整数或浮点
绝对值，保持子类型


math.random(m, n)
整型
[m, n] 闭区间随机整数



四、组合键：两种写法
KeyDown 支持多参数，可以一次按下多个键：
-- 写法 A：分开按
KeyDown("lctrl")
KeyDown("lshift")
KeyTap("n")
KeyUp("lshift")
KeyUp("lctrl")

-- 写法 B：一次按下（等价，更短）
KeyDown("lctrl", "lshift")
KeyTap("n")
KeyUp("lctrl", "lshift")

两种都行。写法 B 的参数顺序不影响结果，松开时顺序也不影响。但按下的与松开的键必须对得上——按了三个只松两个，剩下的会一直粘着，表现是「Ctrl 卡住了」。脚本末尾加 ReleaseAllKeys() 可以兜底。
五、HID 键码
键名直接写字符串就可以，不需要记码值。需要写码值的场合（比如用变量传参），用下面这套规律。
字母与数字：连续编码



范围
键码
换算式




字母 a–z
0x04 – 0x1D
0x04 + (字母序号)，a=0，z=25


数字 1–9
0x1E – 0x26
0x1E + (数字 - 1)


数字 0
0x27
—



例：c = 0x04 + 2 = 0x06 = 6；5 = 0x1E + 4 = 0x22；w = 0x04 + 22 = 0x1A = 26。
常用特殊键



键名
码
键名
码




enter
0x28
escape
0x29


backspace
0x2A
tab
0x2B


spacebar
0x2C
minus
0x2D


equals
0x2E
lbracket
0x2F


rbracket
0x30
backslash
0x31


semicolon
0x33
quote
0x34


tilde
0x35
comma
0x36


period
0x37
slash
0x38


capslock
0x39
appkey
0x65



修饰键



键名
码
说明




lctrl
0xE0
左 Ctrl


lshift
0xE1
左 Shift


lalt
0xE2
左 Alt


lgui
0xE3
左 Win / Command


rctrl
0xE4
右 Ctrl


rshift
0xE5
右 Shift


ralt
0xE6
右 Alt



功能键与编辑键



键名
码
键名
码




f1–f12
0x3A – 0x45
printscreen
0x46


scrolllock
0x47
pause
0x48


insert
0x49
home
0x4A


pageup
0x4B
delete
0x4C


end
0x4D
pagedown
0x4E


right
0x4F
left
0x50


down
0x51
up
0x52



F1–F12 是连续的，f1 = 0x3A 起依次加一。
小键盘



键名
码
键名
码




numlock
0x53
numslash
0x54


numasterisk
0x55
numminus
0x56


numplus
0x57
numenter
0x58


num1–num9
0x59 – 0x61
num0
0x62


numperiod
0x63





六、几个容易记错的地方

equals 是 = 那个键，就是主键盘区 + 的位置（不按 Shift）。想按 + 要 KeyDown("lshift") 配 equals。
tilde 是 ` 那个键（数字 1 左边），不是 ~。
spacebar 不是 space。
appkey 的文档说明写的是「Left Ctrl」，这是文档笔误，码值 0x65 实际是菜单键。不确定就避开不用。
小键盘和主键盘的数字不是同一个键。num5 和 5 在程序看来完全不同——某些软件只认其中一个。

]]></description><link>https://www.byteohm.com/topic/61/内置函数与-hid-键码对照表</link><guid isPermaLink="true">https://www.byteohm.com/topic/61/内置函数与-hid-键码对照表</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:10 GMT</pubDate></item><item><title><![CDATA[Lua 语法速查：这套脚本到底是不是 Lua]]></title><description><![CDATA[先给结论：不是标准 Lua。
键鼠助手里的「Lua」是一个封闭的小语言——解析器只实现了一个子集，能用的命令和函数是两张写死的表（15 条命令 + 9 个函数）。它的语法长得像 Lua，是因为设计时刻意对齐了 Lua 5.3 的书写习惯；但内核、类型系统、标准库都不在。
这意味着：别拿网上任何一篇「Lua 入门教程」直接往里套。 这篇把「像什么」和「哪里不一样」分开写清楚，写完的脚本至少不会卡在编译上。
一、两套方言并存
解析器同时认两种写法：



方言
写法
用不用




Lua 风格
local x = v、if..then..elseif..else..end、while..do..end、for i=a,b,step..do..end、function f(p)..end、do..end、return、break
推荐，文档化的就是这一套


遗留 BASIC 风格
If/Then/EndIf、While/Wend、For/Next、Sub/End Sub、Dim、Goto、Rem、Call、Exit Sub
老脚本兼容用，新脚本别写



两套不能混着嵌套。看到别人的脚本里出现 EndIf，那是老资产，不是你语法错。
二、数据类型



类型
字面量
说明




integer
10、0x04、0b0100
十六进制和二进制都认，0b0100 等于 4


float
2.5、1e3
1e3 是浮点 1000，不是整数


string
"a"
文档里只出现过双引号写法


boolean
true / false



array
Array(n)、StringArray(n, len)
容量在声明时定死


nil
—
见下面第 3 条差异，行为需要实测


字符串变量
StringVar(n)
固定容量的字符串



数值遵循 Lua 5.3 的整数 / 浮点双类型规则，别的地方不一定这么讲究：
local half  = 7 / 2      -- 3.5，/ 永远是浮点除法
local whole = 7 // 2     -- 3，向下整除
local down  = -7 // 2    -- -4，注意是向下取整，不是向零
local mod   = -7 % 3     -- 2，floor 取模
local rem   = 7 % 3      -- 1

-7 // 2 得 -4 而不是 -3，这是最容易算错的一行。
三、与标准 Lua 的六处差异
这六条是实际写脚本时会被绊住的地方，按踩坑概率排序。
1. 数组下标从 0 开始
标准 Lua 的数组从 1 开始，这里从 0 开始。
local nums = Array(5)
nums[0] = 1        -- 第一个元素
nums[1] = 2        -- 第二个
nums[2] = nums[0] + nums[1]   -- 3

把从网上抄来的 for i = 1, 10 套在长度 10 的数组上，会多读一个不存在的槽位。写循环时先想清楚边界是 0..n-1 还是 1..n。
2. 没有通用 table
标准 Lua 的 {} 构造器、#t 取长度、pairs / ipairs 遍历、table.insert 这些，文档里一条都没有，按不可用处理。
能用的容器只有三种：
local nums  = Array(5)              -- 整数数组，5 个槽
local name  = StringVar(16)         -- 单个字符串变量
local names = StringArray(4, 16)    -- 4 个字符串，每个 16

容量是写死的，运行时不会自动扩容。循环里往 Array(5) 写第 6 个元素，结果不可预期——按越界处理。
3. math.tointeger 失败返回 0，不是 nil
文档在数据类型表里列了 nil，但在 math.tointeger 的说明里又写「无 nil 类型，转换失败返回 0」。
local i1 = math.tointeger(7.0)   -- 7
local i2 = math.tointeger(1.5)   -- 0（不是 nil）

两处说法不一致，写代码时按「返回 0」处理更安全：转换失败和真的等于 0 无法区分，所以别把 math.tointeger 的返回值当判断依据。确定要判整数时用 math.type(v)，它返回 "integer" 或 "float"。
4. 没有字符串库
string.format、string.sub、string.find、#s 取长度，文档里都没有。字符串能做的只有拼接：
local text = "键鼠" .. "助手" .. " v1.0"

需要拼接数字时注意整数会变成十进制字面，小数部分按浮点规则；要控制格式，只能靠 Log 的 printf 风格参数输出到日志里看：
Log("count=%d name=%s ratio=%g", 3, "键鼠助手", 1000 * 1.5)

但 Log 是输出，不返回字符串——不能拿它拼出格式化后的文本再 TypeText 出去。需要「输入格式化文本」时，只能把定值写死或分段 TypeText。
5. 0b 二进制字面量
0b0100 = 4。标准 Lua 5.3 不支持这个写法。写键码时用 0b 更直观，但换算成十进制或十六进制也一样，看个人习惯。
6. math.random 只有双参形式
local rnd = math.random(50, 100)   -- [50, 100] 闭区间随机整数

文档只给了这一种形式，没有无参和单参版本。要模拟 0/1 就用 math.random(0, 1)。
四、控制语句
local count = 0

while count &lt; 5 do
    count = count + 1
    if count == 1 then
        -- 第一次
    elseif count == 3 then
        -- 第三次
    else
        -- 其它
    end
end

for i = 1, 3 do
    if i == 2 then
        -- 跳过处理
    end
end

function add(a, b)
    return a + b
end

local sum = add(2, 3)

注释用 --，只支持单行。
break 只能跳出最内层循环；嵌套循环要跳两层，得自己加标志变量逐层判断。
五、踩坑速查



现象
大概率原因




编译报 end 相关错误
容器块没闭合；for 后面漏 do，while 后面漏 do


数组读出来是 0 或者乱值
下标从 1 开始写了，或者越界


math.tointeger 结果不对
转换失败返回 0，被当成有效值用了


想 string.format 拼文本却编译不过
没有字符串库，改用 .. 拼接


循环次数比预期多一轮
0..n-1 与 1..n 混用


Log 输出看不懂
首个参数含 %d/%s/%f 时按 printf 走，不含则按空格分隔；两种模式混用容易错位



六、不确定的行为怎么确认
这套语言的文档只覆盖了「已实现且稳定」的部分，边界行为（比如 nil 到底能不能赋值、字符串容量超了会怎样）没有成文说明。
确认方法只有一条，但很有效：
local v = math.type(nil)
Log("type=%s", v)

编译 → 运行 → 看输出窗口。编译器通过 + 运行输出符合预期，才算确认；只有编译通过不算。
实测出新结论欢迎发到版块里，这类帖子比任何教程都有用——文档没写的地方就是靠这样一条条补出来的。
]]></description><link>https://www.byteohm.com/topic/60/lua-语法速查-这套脚本到底是不是-lua</link><guid isPermaLink="true">https://www.byteohm.com/topic/60/lua-语法速查-这套脚本到底是不是-lua</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:09 GMT</pubDate></item><item><title><![CDATA[按住连发与三种触发方式的组合]]></title><description><![CDATA[同一个脚本，换一种触发方式，行为完全不同。很多人以为宏没生效，其实是触发方式选错了。这篇把三种类型和它们的组合讲清楚。
三种触发类型



类型
什么时候开始执行
什么时候停




按下触发
按键按下的瞬间
脚本跑完自然结束；中途按终止键（默认 ESC）可中断


松开触发
按键松开的瞬间
同上


按下触发松开中断
按键按下的瞬间
松开手指的那一刻立即停止；也支持终止键



关键差别只在最后一行：前两种是「跑完为止」，第三种是「按住多久跑多久」。
各自适合什么
按下触发 —— 一次性动作。输入一段地址、执行一串快捷键、点几下固定位置。按一下，跑完，结束。
松开触发 —— 需要「按下的过程本身有意义」时用。典型是游戏里的蓄力、按住拖拽：按住阶段是手工控制，松开的瞬间才需要宏补一串动作。
按下触发松开中断 —— 持续型动作。连发、按住刷、按住跑循环。这是连点场景的正确选择。
单键两个宏的两种组合
一个键可以同时绑两个宏：按下宏和松开宏。它们有两种组合方式：
组合一：【按下触发，松开触发】
按下执行宏 A（会完整跑完），松开执行宏 B。
按下 → 宏 A 开始执行 ──────→ 执行完
                              ↓（如果这时还按着，松开会触发 B）
松开 → 宏 B 开始执行

适合「正向 + 反向」的一对动作。比如 A 是「选中到列尾」，B 是「回到列首」——先把 A 跑完，再按一次返回。
组合二：【按下触发松开中断，松开触发】
按下执行宏 A，松开立即中断 A，然后执行宏 B。
按下 → 宏 A 开始执行 ──┐
                        ↓（松手）
松开 → 中断 A ───────→ 执行 B

适合「按住持续、松手收尾」。比如 A 是连发，B 是「停止后补一次单击」——松手的瞬间把连发掐掉，立刻补一个干净的单点。
实际例子：连发 + 松手补点
按下宏（连发）：
-- 按下宏：按住期间持续连点
while true do
    MouseClick(1)
    Delay(30)
end

松开宏（补一次）：
-- 松开宏：松手后再点一次，保证最后一下是完整点击
Delay(10)
MouseClick(1)

触发方式选 【按下触发松开中断，松开触发】。这样按住是连发，松手的瞬间连发被掐断，紧接着补一个完整点击——不会出现「松开时正好点到一半」的情况。
三个必须知道的前提
1. 触发键不能是被宏操作的键。 用左键做触发键，宏里又点左键，会自己触发自己，结果是无限递归。连发类宏一律绑侧键或键盘键。
2. 鼠标和键盘的快捷键不通用。 设备类型选的是「插在盒子上的那个设备」。插的是鼠标，配的却是键盘组合键，切换不会生效——不是坏了，是它压根没收到。
3. 终止键要配手边能按到的。 默认是 ESC。如果你插的是小键盘或者只用鼠标，ESC 可能按不到，去 偏好 → 宏中止按键 换成有的键。这一步建议在第一次烧录前就做，尤其是写 while true 的时候。
场景也是隔离的
10 个场景互相独立。同一种触发方式，在不同场景里可以是完全不同的宏。
设了场景切换快捷键之后，切换是纯硬件完成的——不经过电脑上的软件，也不需要软件在后台跑。所以「办公场景」和「晚上场景」可以各有一套绑定，切换一下整套都变。
排查「宏不动作」时，场景是一个高频原因：你以为在场景 1，其实停在场景 3。
]]></description><link>https://www.byteohm.com/topic/59/按住连发与三种触发方式的组合</link><guid isPermaLink="true">https://www.byteohm.com/topic/59/按住连发与三种触发方式的组合</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:09 GMT</pubDate></item><item><title><![CDATA[可控频率连点器：从死循环到带抖动]]></title><description><![CDATA[连点是宏的入门项目，也是最容易被写错的一个。这篇把「频率到底怎么算」讲清楚，剩下的写法都是它的变体。
先搞清一件事：MouseClick 自己就占 20ms
文档里写着 MouseClick 是「按下与松开间隔 20 毫秒」。这句话的准确含义是它内部就是三条子命令：
MouseClick(1)  ==  MouseDown(1) → Delay(20) → MouseUp(1)

那 20ms 不是额外开销，是一条写死在命令里、你改不了的 Delay。这意味着：
实际周期 = 20ms（点击本身） + Delay 的值
实际频率 = 1000 / 实际周期

所以 MouseClick(1) 后面跟 Delay(50)，得到的是 14 次/秒，不是 20 次/秒。想要 20Hz，Delay 要写 30。



想要频率
Delay 该写
实际周期




10 次/秒
80
100ms


20 次/秒
30
50ms


30 次/秒
13
33ms


50 次/秒
0
20ms（MouseClick 的上限）



MouseClick 的天花板是 50 次/秒，因为那 20ms 是写死在命令里的。要更快只能绕过它，用 MouseDown + MouseUp 自己拼（见最后一节）。
写法一：固定次数
最简单，次数写死：
local CLICK_COUNT = 100
local INTERVAL_MS = 30          -- 约 20 次/秒

for i = 1, CLICK_COUNT do
    MouseClick(1)
    Delay(INTERVAL_MS)
end

适合「点一百下就停」的场景。缺点是次数不能临时改，改一次要重新烧录。
写法二：带上限的 while
点数由变量控制，同时留一个硬上限防跑飞：
local MAX_COUNT = 500
local INTERVAL_MS = 30
local count = 0

while count &lt; MAX_COUNT do
    MouseClick(1)
    Delay(INTERVAL_MS)
    count = count + 1
end

MAX_COUNT 是一道保险。写 while true 而忘了上限，又没配中断键，脚本会一直点下去直到你拔设备——这种事故在这类设备上一律靠「触发方式」兜底，下面就讲。
写法三：按住连发（靠触发方式中断）
连发不需要在脚本里判断「什么时候停」，交给触发方式：选用按下触发松开中断，按住执行、松手立即停。脚本本身可以写成无限循环：
-- 按住左键连点，松手由「按下触发松开中断」停止
while true do
    MouseClick(1)
    Delay(30)
end

️ 这段必须绑「按下触发松开中断」或「按下触发（ESC 中断）」。 如果绑成「按下触发」且没配终止键，它会一直点下去。
同理，要用鼠标左键本身做触发键，就不能再让脚本点左键——那样会自我触发。连发类宏一般绑在侧键上。
加抖动的意义
固定间隔的点击是「机器节奏」，某些程序（比如需要人工操作确认的界面）会对完全规律的输入做过滤。给间隔加一点随机偏移，节奏更像人：
local BASE_MS = 30
local JITTER_MS = 4           -- 实际间隔在 26–34ms 之间

while true do
    MouseClick(1)
    Delay(BASE_MS + math.random(-JITTER_MS, JITTER_MS))
end

math.random(m, n) 是闭区间，能取到两端。JITTER_MS 不要给太大——抖动过大会让整体频率明显变慢（随机值均值仍为中心，但最大值那一侧拉长了周期）。
要突破 50 次/秒
MouseClick 的 20ms 是硬上限。要更快，拆成按下、松开两步自己控制间隔：
-- 约 500 次/秒；实际受设备回报率限制（最高 1K）
while true do
    MouseDown(1)
    Delay(1)
    MouseUp(1)
    Delay(1)
end

注意两点：

回报率是天花板。设备最高支持 1K（1000Hz），即最小间隔 1ms。写 Delay(0) 也不会比这更快。
很多程序接不住这么快的点击。GUI 程序一般一次点击要 16ms 以上才处理得完，超出的会被合并或丢弃。频率高不等于有效点击多，实际调的时候以「目标程序真的响应了」为准。

一个实用的调试办法
不确定实际频率是多少时，让脚本自己报数：
local start = GetUpTime()
local count = 0

while count &lt; 100 do
    MouseClick(1)
    Delay(30)
    count = count + 1
end

local cost = GetUpTime() - start
Log("100 次实际耗时 %d ms，平均 %d ms/次", cost, cost // 100)

在软件里点「运行Lua脚本」，输出窗口会打出真实数字。这是唯一能确认「你以为的频率」和「实际频率」是否一致的方法，比拿秒表数强。
]]></description><link>https://www.byteohm.com/topic/58/可控频率连点器-从死循环到带抖动</link><guid isPermaLink="true">https://www.byteohm.com/topic/58/可控频率连点器-从死循环到带抖动</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:09 GMT</pubDate></item><item><title><![CDATA[剪辑软件的时间轴宏：Pr 与剪映]]></title><description><![CDATA[剪辑里最机械的一段是「切、删、移、再看一遍」。一个三分钟的片子切两百刀，每刀都是同样三个动作。这段可以交给宏。
Premiere：切一刀 + 波纹删除
Pr 里最常用的一对操作是「添加编辑」和「波纹删除」——前者在播放头位置切开素材，后者删掉前一段并让后面的素材自动前移。
-- 在播放头位置切一刀，然后删掉前一段
KeyDown("lctrl")
KeyTap("k")               -- 添加编辑
KeyUp("lctrl")
Delay(180)                -- 切点渲染，给足

KeyDown("lshift")
KeyTap("delete")          -- 波纹删除
KeyUp("lshift")
Delay(180)

延时为什么给到 180ms：Pr 的「添加编辑」会重绘时间轴上的切点，切点没渲染完就发删除，可能删到整段素材而不是前一段。这类「改结构」的操作，延时按渲染时间给，不按按键响应时间给。
批量：连切 N 刀
配合「方向键逐帧 + 切」可以做成一个重复动作。下面这段每次前进 15 帧切一刀，连续 20 次：
local STEP_FRAMES = 15
local CUT_COUNT = 20

for i = 1, CUT_COUNT do
    for f = 1, STEP_FRAMES do
        KeyTap("right")
        Delay(12)
    end
    KeyDown("lctrl")
    KeyTap("k")
    KeyUp("lctrl")
    Delay(160)
end

逐帧用方向键，Delay(12) 就够——时间轴的光标移动是本地操作，不涉及渲染。但 Ctrl+K 之后要等 160ms。
先拿 3 刀试。 刀具节奏和素材长度必须匹配，切多了要撤销几十次，比手动还慢。
剪映：分割 + 删除
剪映专业版的快捷键与 Pr 不完全一致，常用的两个是 Ctrl+B 分割、Delete 删除：
KeyDown("lctrl")
KeyTap("b")               -- 分割
KeyUp("lctrl")
Delay(150)

KeyTap("delete")
Delay(120)

剪映在低配机器上响应比 Pr 慢，延时建议整体上浮 50–100ms。判断标准很简单：在你自己机器上，动作不丢就是够，偶尔丢一次就是不够。
时间轴缩放：让切点落在可点位置
时间轴缩得太开，一刀要看半天；缩得太紧，切点对不准。Pr 里 + / - 缩放时间轴：
-- 缩放到能看见整段，再放大两档精修
KeyDown("backslash")      -- \ 缩放到序列全长（Pr 默认）
KeyUp("backslash")
Delay(200)

KeyTap("equals")          -- + 放大
KeyTap("equals")
Delay(120)

= 键在多数键盘上就是 + 的位置（不按 Shift）。脚本里写 equals，HID 码 0x2E。
一条完整的「粗剪一个片段」
-- 粗剪：前进 2 秒 → 切 → 波纹删 → 重复 10 次
-- 前提：播放头已停在要开始的帧上；出问题按 Ctrl+Z 逐次撤回

for i = 1, 10 do
    -- 前进 2 秒（25fps 约 50 帧）
    for f = 1, 50 do
        KeyTap("right")
        Delay(10)
    end

    KeyDown("lctrl")
    KeyTap("k")
    KeyUp("lctrl")
    Delay(160)

    KeyDown("lshift")
    KeyTap("delete")
    KeyUp("lshift")
    Delay(160)
end

ReleaseAllKeys()

几个必须注意的点
1. 撤销是唯一的兜底。 批量删除是不可逆的（Pr 的撤销栈有深度限制）。跑之前先存盘，跑的时候盯着，出问题立刻 Ctrl+Z。宏里没法「判断删对没删对」——它看不见时间轴。
2. 焦点必须在时间轴上。 这些快捷键（尤其 Delete）在项目面板、效果面板里的含义完全不同。触发前先点一下时间轴区域，或者把「点击时间轴」写进宏的第一步。
3. 别用宏做需要判断的剪辑。 「把每段静音部分剪掉」这种需要看波形的活，宏做不了。它能做的是「按固定间隔切固定刀数」，仅此而已。
4. 帧率要算进去。 上面用「方向键次数」表示时间，是因为一格 = 一帧。25fps 下 50 格 = 2 秒，60fps 下 50 格只有 0.83 秒。换项目帧率了，步进次数要跟着改。
]]></description><link>https://www.byteohm.com/topic/57/剪辑软件的时间轴宏-pr-与剪映</link><guid isPermaLink="true">https://www.byteohm.com/topic/57/剪辑软件的时间轴宏-pr-与剪映</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:08 GMT</pubDate></item><item><title><![CDATA[Photoshop 高频操作宏：图层、笔刷、定位]]></title><description><![CDATA[修图和绘图里真正磨时间的不是「画」，是画之前那一串准备动作：切图层、调笔刷、复位色板、回到 100%、点回画布某个位置。这些动作顺序固定，正好是宏的活。
把笔刷调到固定大小
笔刷大小是相对的——[ 缩小、] 放大，每次一个档位，但你不知道当前在哪一档。想要每次都得到同一个大小，办法是先归零再步进：
-- 先把笔刷压到最小，再放大 5 档
for i = 1, 40 do
    KeyTap("lbracket")      -- [ 缩小
    Delay(8)
end

for i = 1, 5 do
    KeyTap("rbracket")      -- ] 放大
    Delay(8)
end

多按几下缩到最小是安全的，到底之后继续按不会有副作用。这样「5 档」就是一个确定的尺寸，不依赖触发前的状态。
复位色板与切换前景背景
D 把前景 / 背景复位成黑 / 白，X 交换两者。这两个键在修图里按得极多：
-- 回到黑前景 + 白背景
KeyTap("d")
Delay(30)

把它做成一个宏，绑在顺手的位置，比每次去按键盘省事——尤其你一只手正握着笔的时候。
图层的常规三连
-- 复制当前层 → 新建组 → 把副本放进组里
KeyDown("lctrl")
KeyTap("j")               -- 复制图层
KeyUp("lctrl")
Delay(150)

KeyDown("lctrl")
KeyDown("lshift")
KeyTap("n")               -- 新建图层
KeyUp("lshift")
KeyUp("lctrl")
Delay(400)                -- 会弹对话框，等它出来

注意最后那个 Delay(400)：Ctrl+Shift+N 在 Photoshop 里会弹新建图层对话框，对话框没出来就继续发按键，后面的动作会打到画布上。凡是会弹窗的操作，延时都要按「等窗口渲染」给。
如果只是想跳过对话框，用 Ctrl+Shift+Alt+N（无对话框新建图层），延时可以降到 100ms 以内。
坐标定位：把点击落到画布上的固定位置
ScreenSize(1920, 1080)    -- 声明脚本参照的分辨率
MoveMouse(960, 540)       -- 移到屏幕正中
Delay(50)
MouseClick(1)

ScreenSize 声明的是脚本的设计分辨率。实际屏幕不是这个尺寸时，坐标会按比例换算：
实际位置 x = 设计 x × 实际宽 / 设计宽
实际位置 y = 设计 y × 实际高 / 设计宽

注意 y 那一行用的是设计宽做分母——这是文档里写明的换算公式，不是笔误。分辨率比例和 16:9 差得远时（比如 16:10 的屏），y 会偏。这种情况直接把 ScreenSize 改成实际分辨率更省事。
Mac 上的一个坑：系统会丢弃与上一次完全相同的移动事件。连续两次 MoveMouse 到同一个点，第二次不生效。解决办法是加一点微抖：
MoveMouse(960, 540)
MoveMouseBy(1, 0)
MoveMouseBy(-1, 0)
Delay(50)
MouseClick(1)

来回 1 像素，视觉上看不出来，但事件不再重复。
一条完整的准备序列
把上面几段拼起来，就是「开始画之前」的一键准备：
-- 画前准备：复位色板、笔刷归零到 5 档、回到 100% 视图、点回画布中心
KeyTap("d")
Delay(40)

for i = 1, 40 do
    KeyTap("lbracket")
    Delay(8)
end
for i = 1, 5 do
    KeyTap("rbracket")
    Delay(8)
end

KeyDown("lctrl")
KeyTap("1")               -- 100% 视图
KeyUp("lctrl")
Delay(200)

ScreenSize(1920, 1080)
MoveMouse(960, 540)
MoveMouseBy(1, 0)
MoveMouseBy(-1, 0)
Delay(50)

几个提醒

Photoshop 的快捷键可以用自定义工作区改掉。如果你改过，脚本里的键位要跟着改，否则就是「在别人的电脑上能用、在我这儿乱按」。
弹窗类操作（新建、导出、保存为 Web）延时必须给足，宁可多给 200ms。
涉及 Ctrl+Z 的兜底：图层类操作一旦串了，撤销是最快的恢复手段，脚本注释里写清楚。

]]></description><link>https://www.byteohm.com/topic/56/photoshop-高频操作宏-图层-笔刷-定位</link><guid isPermaLink="true">https://www.byteohm.com/topic/56/photoshop-高频操作宏-图层-笔刷-定位</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:08 GMT</pubDate></item><item><title><![CDATA[把一串重复操作压成一次按键]]></title><description><![CDATA[快捷键序列是宏最本分的用法：一个动作要按四次组合键、还得按固定顺序，那就把它压成一次。
基本结构：按住、敲、松开
宏里的组合键不能写成 Ctrl+C 这种字符串，要拆成三步：
KeyDown("lctrl")
KeyTap("c")
KeyUp("lctrl")

KeyTap 本身没有独立的底层动作，它就是三条子命令的组合：



写法
实际执行




KeyTap("c")
KeyDown("c") → Delay(20) → KeyUp("c")



所以上面三行等于「按住 Ctrl，敲一下 C，松开 Ctrl」——那 20ms 的按下-松开正好夹在 KeyDown 与 KeyUp 之间，Ctrl 全程没被松开过。这也是组合键必须写成三段式的原因：真正让两个键同时处于按下状态的是 KeyDown 和 KeyUp 的位置，不是 KeyTap。
一个容易想错的地方：KeyTap 传多个参数是逐个串行点击，不是同时按下。
KeyTap("a", "b")   -- a 按下 → 20ms → a 松开 → b 按下 → 20ms → b 松开

两个键从不同时按住，总耗时 40ms 起，键越多叠得越多。要两个键同时按住，用 KeyDown("a", "b")；KeyTap 的多参数只在「连续敲几个键」时才有意义。
修饰键必须先按下、后松开，中间夹目标键。写成 KeyTap("c") 然后 KeyTap("lctrl") 是无效的——那是先打了 c 再按了一下 Ctrl。
一个真实例子：整列搬到另一张表
Excel 里常见的动作序列：选中当前列 → 复制 → 切到另一个表 → 定位 → 粘贴。
-- 选中整列（Ctrl + 空格），复制
KeyDown("lctrl")
KeyTap("spacebar")
KeyUp("lctrl")
Delay(60)

KeyDown("lctrl")
KeyTap("c")
KeyUp("lctrl")
Delay(120)             -- 复制到剪贴板需要时间，别省

-- 切换到下一个工作表
KeyDown("lctrl")
KeyTap("pagedown")
KeyUp("lctrl")
Delay(250)             -- 切表比一般操作慢，给足

-- 跳到 A1 并粘贴
KeyDown("lctrl")
KeyTap("home")
KeyUp("lctrl")
Delay(60)

KeyDown("lctrl")
KeyTap("v")
KeyUp("lctrl")

延时怎么给
这张表是按「目标软件的响应速度」排的，不是按理论值：



动作
建议延时
原因




普通快捷键
60–80ms
界面刷新一帧就够


复制 / 剪切
100–150ms
剪贴板写入是异步的


切换工作表 / 标签页
200–300ms
整页重绘


打开对话框
300–500ms
等窗口出来再输入


保存 / 导出
800ms 以上
磁盘 IO，不可控



原则：给接收方的耗时永远比你估计的长。宁多给 50ms（人感觉不出来），也不要少给导致动作串到上一个状态上。
ReleaseAllKeys 什么时候用
它释放所有键盘按键。用在这些场合：

宏结束前兜底。万一中间某步异常退出，修饰键会一直处于按下状态，用户感觉到的是「Ctrl 粘住了」。脚本末尾加一行 ReleaseAllKeys() 可以避免。
两种操作模式之间切换。前一段是「按住 Shift 连续点」，后一段是纯点击，中间清一次状态比较干净。

-- 末尾兜底
ReleaseAllKeys()

它不需要参数，也不会有副作用——没有按下的键，调用它什么也不做。
配合场景切换用
一套宏通常不止一个用途：白天办公、晚上别的用途。10 个场景就是为这个准备的。

每个场景可以配自己的切换快捷键，纯硬件切换（不经过电脑软件）；
场景互相独立，同一个键在不同场景可以绑不同的宏；
偏好页里可以给场景命名，只存在本地，方便自己认。

所以「办公宏」和「其他宏」不用挤在一个剧本里靠 if 判断，直接分场景更干净。
三个容易忽略的细节
1. 目标窗口必须先获得焦点。 宏只发按键，不切窗口。如果触发时焦点在别的程序上，这一串按键就全打到别的程序里了。要么手动先点一下，要么把「点击目标窗口」写进宏的第一步（MouseClick 到窗口标题栏）。
2. 中文输入法会吃掉字母键。 输入法处于中文状态时，KeyTap("c") 可能变成候选词输入。涉及字母键的序列，在脚本开头把输入法切到英文，或者要求使用者在触发前切好。
3. 撤销是最好的兜底。 序列里某一步没生效，后面的动作会作用在错误状态上，可能产生难以回退的后果（比如批量删除了内容）。在开头的注释里写清「出问题按 Ctrl+Z 撤回」，比任何代码都实用。
]]></description><link>https://www.byteohm.com/topic/55/把一串重复操作压成一次按键</link><guid isPermaLink="true">https://www.byteohm.com/topic/55/把一串重复操作压成一次按键</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:07 GMT</pubDate></item><item><title><![CDATA[一键输入常用长文本：TypeText 的两种模式]]></title><description><![CDATA[地址、邮箱、公司抬头、客服模板句、报税编号——这些内容每次都要一个字一个字敲，是办公场景里最典型的浪费。TypeText 就是干这个的。
基本写法
-- 把常改的部分提到最前面
local ADDRESS = "北京市海淀区中关村大街 1 号 A 座 1201"

TypeText(ADDRESS)

编译期它会被展开成一串按键动作——TypeText 不是运行时逐个字符打出来的，而是编译时就把文本编码成 Alt + 小键盘（或 Option + HEX）序列。这一点决定了它的适用范围，后面细说。
Windows：默认 GBK，用 Alt + 小键盘
TypeText("你好")                -- 等价于 mode="gbk"
TypeText("你好😀", "unicode")   -- Emoji 走 Unicode 码点


GBK 覆盖常用汉字，编码短、按键次数少；
Emoji、生僻字、日文假名之外的特殊符号，GBK 编不了，必须显式给 "unicode"。

前提条件，三条缺一不可：

小键盘可用。Alt + 小键盘数字是靠 num0–num9 打的，笔记本没有独立小键盘、NumLock 关着的，全部打不出来；
输入法处于英文 / 直连状态。中文输入法开着的时候，Alt + 数字可能被输入法截走；
目标程序接受 Alt 组合键。极少数程序把 Alt 当菜单键，会在输入过程中弹出菜单栏。

macOS：默认 Unicode，用 Option + HEX
TypeText("你好")   -- 等价于 mode="unicode"，展开为 Option + HEX

用之前必须先在 系统设置 → 键盘 → 输入法 / 输入源 里启用并切换到 Unicode Hex Input。
macOS 不支持 mode="gbk"——GBK 机内码输入属于 Windows 输入体系，在 Mac 上没有对应机制。
长度：这是最容易踩的坑
因为编译期展开，文本长度直接换算成按键次数。一个汉字在 GBK 下是 2 字节，每个字节展开成「Alt + 4 位数字 + 松开」，大约 6 次按键动作。
粗算一下：



文本长度
大致按键动作数
实际耗时




10 个汉字
约 120 次
1–2 秒


50 个汉字（一段地址）
约 600 次
6–10 秒


500 个汉字（一篇文章）
约 6000 次
一分钟以上，且极易被目标程序截断



所以：

适合：地址、邮箱、模板句、编号、十几到几十个字的内容；
不适合：整段落、整篇文章。真要批量输入正文，用系统的输入法自定义短语或者剪贴板，不要用 TypeText。

超过 100 字就该重新想方案了。
一个实用的组合：替换而不是追加
输入前先全选，能保证结果是替换而不是拼在后面：
local TEMPLATE = "您好，您反馈的问题我们已收到，会在 24 小时内处理。"

KeyDown("lctrl")
KeyTap("a")
KeyUp("lctrl")
Delay(80)              -- 等目标程序完成全选
TypeText(TEMPLATE)

Delay(80) 这一步不要省。全选是异步的，紧接着就输入，前面几个字符可能打进旧选区。
现场排查



现象
原因




打出来是一串数字，不是文字
小键盘 NumLock 关着，或输入法处于中文状态


只有前几个字进去，后面丢了
目标程序有输入长度或速率限制，把 TypeText 拆成几段、中间加 Delay


弹出了程序菜单
目标程序把 Alt 当菜单键，换用剪贴板方案


Emoji 变成问号或方块
没给 "unicode"，GBK 编不出来


Mac 上完全没反应
没切到 Unicode Hex Input 输入源



什么时候不该用它
如果目标是「把一段固定内容填进某个字段」，还有一个更省事的思路：能不能让目标软件自己读取？ 比如表格的自动填充、Word 的自动图文集、输入法的自定义短语。这些方案不占宏时长，也不受输入法状态影响。
宏的价值在于跨软件、跨界面、目标程序没有现成功能时的那一下。能用软件自带功能解决的，优先用自带功能。
]]></description><link>https://www.byteohm.com/topic/54/一键输入常用长文本-typetext-的两种模式</link><guid isPermaLink="true">https://www.byteohm.com/topic/54/一键输入常用长文本-typetext-的两种模式</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:07 GMT</pubDate></item><item><title><![CDATA[从零到烧录：五步做出第一个宏]]></title><description><![CDATA[第一个宏不要做复杂的东西。这篇用最基础的「连点 10 次、每次隔 50 毫秒」走完全流程，五个步骤每一步都能看到结果，走完你就知道这套东西是怎么转的了。
第 0 步：先确认手上有什么
打开 → 关于，记下两个东西：

软件版本 / 固件版本——以后所有求助帖都要写这个；
设备标识号（右键可复制）。

插上盒子，状态栏第一栏应该是已连接。如果是红的，先解决连接，别往下走。
第 1 步：写
主界面 → 宏编辑。默认三栏，某栏不见了就贴着窗口边缘往外拖。

左栏是宏目录，右键可以新建文件夹 / 新建宏 / 重命名；
中栏是编辑器，脚本写这里；
右栏是函数说明，输入关键字就能查。

先在左栏右键新建一个宏，命名 learn-click10，然后在中间写：
-- 连点 10 次，每次间隔 50 毫秒
for i = 1, 10 do
    MouseClick(1)
    Delay(50)
end

MouseClick(1) 的 1 是左键（1 左 / 2 右 / 3 中 / 4 侧后 / 5 侧前），Delay 单位是毫秒。
这时脚本还不能跑，得先让编译器看一眼。
第 2 步：编译
点工具栏第一个按钮（编译）。

下方输出窗口没报错 = 语法通过；
报错了会指到行，照着改。常见的是 end 少一个、for 后面漏了 do。

编译只查语法，它不执行任何东西。
第 3 步：在软件里跑一遍
点工具栏第二个按钮（运行Lua脚本）。
鼠标会开始动——注意提前把光标放到安全位置，这一步是真的在点。10 次点完脚本自己结束。
一个必须记住的前提：软件里跑通，不代表硬件里一致。软件侧是把脚本解释执行，硬件侧是编译成字节码后在盒子上跑，速度更快，链路不同。验证阶段的意义是「流程对不对」，手感对不对要烧录后才知道。
第 4 步：绑定
切到 宏绑定 页。三个下拉决定这个宏什么时候响：



下拉
选什么
说明




设备类型
键盘 / 鼠标
选的是插在盒子上的那个设备，不是你手上按的那个


触发按键
键盘可绑全部 HID Usage 键，鼠标支持五键
弹出列表后可以直接敲键盘快速选中


触发类型
按下触发 / 松开触发 / 按下触发松开中断
决定「什么时候开始」和「什么时候停」



左边列表是当前场景（共 10 个场景，可各自配切换快捷键）。点列表左下角添加，选中刚写的 learn-click10 加进来，然后配上面三个下拉。
这里有一个最容易踩的坑：设备类型必须和实际插的设备一致。插的是鼠标却把快捷键配成键盘组合键，切换不生效——不是坏了，是它压根没收到。
第 5 步：烧录与验证
点宏绑定列表上的第二个按钮（烧录）。这一步把配置写进硬件，之后即使不装软件、不插电脑到原机，盒子插上就能用。
验证：

把设备插到盒子上（不要直插电脑）；
按你绑定的那个键；
状态栏第二栏变绿 = 宏在执行，红 = 没跑。

跑起来了，第一个宏就成了。想改参数，回来改脚本 → 编译 → 重新烧录，三步。
五个容易卡住的地方
1. 停不下来。 默认终止键是 ESC。如果你插的是小键盘或鼠标，ESC 可能按不到——去 偏好 → 宏中止按键，配一个手边有的键。这一步建议在第一次烧录前就做。
2. 烧完没反应。 按顺序查：设备类型对不对 → 触发键对不对 → 触发类型对不对 → 场景对不对（10 个场景互相独立，你可能在别的场景里）→ 烧录到底成没成功。
3. 一插设备软件就卡死 / 加载超时。 这是「自动加载宏」把大量宏一次性读进来造成的。处理办法：拔掉设备 → 进偏好把自动加载宏取消勾选 → 插回设备 → 烧录 → 清空所有绑定的宏。恢复后再一项项加回去。
4. 宏执行时按键没反应。 不用慌，这是设计如此：宏按键无冲，宏在跑的时候你仍然可以正常打字，不需要等它结束。
5. 手感忽快忽慢。 单次 Delay 误差小于 1ms，但宏的整体节奏还受目标软件响应速度影响。给接收方留出处理时间，比把延时调精确更有效——具体见《延时精度与宏时长预算》。
下一步

想不写代码也能做宏 → 《图形化块编程入门》，同一份脚本的两种看法，随时切；
想搞清这套语言的边界 → 《Lua 语法速查》；
想拿现成的改 → 《一键输入常用长文本》和《可控频率连点器》。

]]></description><link>https://www.byteohm.com/topic/53/从零到烧录-五步做出第一个宏</link><guid isPermaLink="true">https://www.byteohm.com/topic/53/从零到烧录-五步做出第一个宏</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:07 GMT</pubDate></item><item><title><![CDATA[写在前面：这些脚本怎么用、什么不该做]]></title><description><![CDATA[这一系列帖子讲的是在硬件里跑的 Lua 宏脚本——脚本由键鼠助手编译成字节码烧进盒子，之后脱机执行，盒子插上就生效，不需要开着电脑上的软件。
动笔之前先说清楚边界，省得你照着写完一篇再发现方向不对。
这套东西擅长什么
一句话：把「一串固定的键盘鼠标动作」压成一次按键。
它只做输出，不看屏幕、不读内存、不判断游戏状态。所以它适合的场景有个共同特征——下一步该按什么，你事先就知道：

输入一段固定的长文本（地址、模板、代码片段）；
重复点同一个位置（软件界面里的批量操作）；
一串有固定顺序的快捷键（软件里的组合操作）；
按固定节奏连续点击（点住不放的场景）。

反过来，凡是需要「看到什么再决定按什么」的，它做不到。比如「血量低于 30% 自动喝药」「看到敌人自动开枪」——这类需要读取游戏状态，硬件盒子没有这个能力，任何声称能做到的脚本都是在骗你。
什么不做
面向联机对战游戏的一切脚本。 包括后坐力补偿、自动连发、快速切枪、自动瞄准、连跳。这条没有例外。
两个原因：

硬件盒子的输入由独立 HID 设备发出，反作弊读不到进程——它绕过的正是公平竞技赖以成立的那道检测。同局其他玩家不知道自己面对的不是人。
这类脚本的寿命以补丁周期计。参数依赖当版本的武器后坐力、灵敏度、FOV、DPI、倍镜倍率，任一变化就失效。写出来三个月就废。

单机、离线、游戏自带训练场的场景可以讨论，那是另一回事——没有第三方玩家受影响。这类脚本会明确标注适用范围，见《单机游戏宏的边界：能做什么、不能做什么》。
发脚本的格式
标题写清楚做什么，不要写「求助」「大佬看看」：
✅ 一键输入收货地址（含 Unicode 模式说明）
✅ 按住左键连发 15 次/秒，松开停止
❌ 求助！！急！！

正文至少包含四样：



项
说明




用途
一句话说清这个宏触发后会发生什么


版本
软硬件版本（关于页可查，如 5.13 / 固件 x.x）


触发方式
绑在哪个键、哪种触发类型（按下 / 松开 / 按下触发松开中断）


脚本
用 lua 代码块，参数写成变量放开头，别散在正文各处



模板：
**用途**：在地址栏输入公司收货地址
**版本**：键鼠助手 5.13
**触发**：鼠标侧后键，按下触发
**前提**：Windows，默认 GBK 模式

```lua
-- 地址文本，改这里就行
local ADDRESS = "北京市海淀区……"
TypeText(ADDRESS)
```

提问的格式
三样缺一样都很难帮上：

你想让它做什么；
它实际做了什么（现象，不是「不行」）；
脚本原文 + 编译输出窗口的原文。

编译能过但硬件不动作，多半不在代码里——先看《编译通过但设备不动作：排查清单》，那五条能解决大部分。
一个必须记住的前提
Delay 的误差小于 1ms，但那是单次延时的精度。一个宏里叠二十次延时，累积误差和软件响应时间才是实际手感。
另外：软件里跑通不等于硬件里一致。软件侧是解释执行，硬件侧是字节码在盒子上跑，链路不同。写完先点「运行Lua脚本」验证流程，最终以烧录后的实测为准。
]]></description><link>https://www.byteohm.com/topic/52/写在前面-这些脚本怎么用-什么不该做</link><guid isPermaLink="true">https://www.byteohm.com/topic/52/写在前面-这些脚本怎么用-什么不该做</guid><dc:creator><![CDATA[admin]]></dc:creator><pubDate>Thu, 05 Nov 2026 16:46:06 GMT</pubDate></item></channel></rss>