解放双手！KeymouseGo语音识别插件：打造语音控制的自动化操作流

2026-02-05 05:18:42作者：郁楠烈Hubert

你是否正在经历这些痛点？

当你在进行重复性电脑操作时，是否经常遇到以下困扰：

双手被键盘鼠标占用，无法同时处理纸质文档或进行口头沟通
复杂快捷键组合难以记忆，频繁查阅手册降低工作效率
编程或数据录入时，切换输入法打断思维连贯性
游戏或远程控制场景中，物理操作延迟影响体验

现在，这些问题将成为历史！ 本文将带你从零构建一个基于KeymouseGo的语音识别插件，实现"动口不动手"的高效自动化操作。通过语音命令控制鼠标键盘，让你的双手真正解放出来。

读完本文你将获得：

语音转文字自动化工具的完整实现方案
3种核心语音控制场景的代码模板（文本输入/界面操作/快捷命令）
插件开发的标准化流程与最佳实践
5个实用语音指令集与扩展思路

项目基础认知：KeymouseGo插件架构

KeymouseGo作为一款类似按键精灵的自动化操作工具，其插件系统采用了松耦合架构设计，允许开发者通过标准化接口扩展核心功能。语音识别插件将基于此架构实现语音命令到鼠标键盘操作的转换。

插件系统核心组件

classDiagram
    class PluginInterface {
        +register_functions() Dict[str, Callable]
        +register_record_functions() List[Callable]
    }
    
    class PluginManager {
        +plugins List[PluginInterface]
        +functions Dict[str, Callable]
        +discover_plugin()
        +register_plugin()
        +call(function_name, params)
    }
    
    class VoiceRecognitionPlugin {
        +meta PluginMeta
        +register_functions()
        +voice_to_text(audio_data) str
        +text_to_action(text) ScriptEvent
    }
    
    PluginInterface <|-- VoiceRecognitionPlugin
    PluginManager "1" --> "*" PluginInterface : manages

工作流程时序图

sequenceDiagram
    participant User
    participant Mic as 麦克风
    participant VAD as 语音活动检测
    participant ASR as 语音识别引擎
    participant Parser as 指令解析器
    participant KMG as KeymouseGo核心
    
    User->>Mic: 说出命令"打开记事本并输入Hello"
    Mic->>VAD: 音频流
    VAD->>ASR: 检测到语音活动
    ASR->>Parser: "打开记事本并输入Hello"
    Parser->>KMG: 生成操作序列
    KMG->>KMG: 执行打开程序+输入文本操作

环境准备与依赖安装

开发环境配置

# 克隆项目仓库
git clone https://gitcode.com/gh_mirrors/ke/KeymouseGo
cd KeymouseGo

# 创建虚拟环境
python -m venv venv
source venv/bin/activate  # Linux/Mac
venv\Scripts\activate     # Windows

# 安装基础依赖
pip install -r requirements-windows.txt  # Windows系统
# 或
pip install -r requirements-universal.txt  # 跨平台版本

# 安装语音识别相关依赖
pip install pyaudio SpeechRecognition python-dotenv

目录结构规划

KeymouseGo/
├── Plugin/
│   ├── Interface.py        # 插件接口定义
│   ├── Manager.py          # 插件管理类
│   └── VoiceRecognition/   # 语音识别插件目录
│       ├── __init__.py
│       ├── manifest.json5  # 插件元数据
│       ├── main.py         # 核心实现
│       └── config.py       # 配置文件
└── ...

语音识别插件开发实战

1. 插件元数据定义 (manifest.json5)

{
  "name": "VoiceRecognition",
  "version": "1.0.0",
  "description": "语音控制插件，将语音命令转换为KeymouseGo自动化操作",
  "author": "Your Name",
  "entry": "main.py",
  "plugin_class": "VoiceRecognitionPlugin",
  "dependencies": {
    "pyaudio": "0.2.13",
    "SpeechRecognition": "3.10.0"
  },
  "settings": {
    "hotkey": "f10",          // 语音控制激活热键
    "language": "zh-CN",      // 识别语言
    "timeout": 5,             // 语音输入超时(秒)
    "energy_threshold": 300   // 声音能量阈值
  }
}

2. 插件核心实现 (main.py)

from abc import ABC
import speech_recognition as sr
from typing import Dict, Callable, List
import pyaudio
import threading
import time
from Plugin.Interface import PluginInterface, PluginMeta
from Event.ScriptEvent import ScriptEvent
from Util.Global import Global


class VoiceRecognitionPlugin(PluginInterface, ABC):
    def __init__(self, manifest: Dict):
        super().__init__(manifest)
        self.recognizer = sr.Recognizer()
        self.microphone = sr.Microphone()
        self.is_listening = False
        self.hotkey = manifest["settings"]["hotkey"]
        self.language = manifest["settings"]["language"]
        self.timeout = manifest["settings"]["timeout"]
        self.energy_threshold = manifest["settings"]["energy_threshold"]
        
        # 设置声音识别阈值
        with self.microphone as source:
            self.recognizer.adjust_for_ambient_noise(source)
            self.recognizer.energy_threshold = self.energy_threshold
            
        # 注册热键监听
        Global.hotkey_manager.register(self.hotkey, self.toggle_listening)

    def register_functions(self) -> Dict[str, Callable]:
        """注册插件功能"""
        return {
            "voice_to_text": self.voice_to_text,
            "text_to_action": self.text_to_action,
            "start_listening": self.start_listening,
            "stop_listening": self.stop_listening
        }

    def register_record_functions(self) -> List[Callable]:
        return []
    
    def toggle_listening(self):
        """切换监听状态"""
        self.is_listening = not self.is_listening
        if self.is_listening:
            self.start_listening()
        else:
            self.stop_listening()

    def start_listening(self):
        """开始语音监听"""
        if not self.is_listening:
            self.is_listening = True
            self.listening_thread = threading.Thread(target=self._listen_loop, daemon=True)
            self.listening_thread.start()
            print("[语音识别] 开始监听，按F10停止...")

    def stop_listening(self):
        """停止语音监听"""
        self.is_listening = False
        print("[语音识别] 停止监听")

    def _listen_loop(self):
        """语音监听循环"""
        while self.is_listening:
            try:
                with self.microphone as source:
                    print("\n[语音识别] 请说话...")
                    audio = self.recognizer.listen(
                        source, 
                        timeout=self.timeout,
                        phrase_time_limit=10
                    )
                
                # 调用语音识别API
                text = self.voice_to_text(audio)
                if text:
                    print(f"[语音识别] 识别结果: {text}")
                    self.text_to_action(text)
                
            except sr.WaitTimeoutError:
                print("[语音识别] 监听超时，请重试")
                continue
            except sr.UnknownValueError:
                print("[语音识别] 无法理解音频")
            except sr.RequestError as e:
                print(f"[语音识别] API请求失败: {e}")
            except Exception as e:
                print(f"[语音识别] 发生错误: {e}")
                self.is_listening = False

    def voice_to_text(self, audio) -> str:
        """语音转文字实现"""
        # 本地识别(离线)
        # 使用Sphinx(CMU Sphinx)引擎，不推荐用于中文识别
        # text = self.recognizer.recognize_sphinx(audio, language=self.language)
        
        # 在线识别(需要网络)
        try:
            # 使用Google Web Speech API(免费但需要网络)
            return self.recognizer.recognize_google(
                audio, 
                language=self.language,
                show_all=False
            )
        except sr.UnknownValueError:
            return "无法识别语音"
        except sr.RequestError as e:
            return f"请求失败: {e}"

    def text_to_action(self, text: str) -> None:
        """文本转操作指令"""
        from KeymouseGo import Recorder
        from Util.RunScriptClass import generate_event
        
        # 简单指令映射示例
        command_map = {
            r"打开记事本": [
                generate_event("key", ["press", "meta", "r"]),
                generate_event("text", "notepad"),
                generate_event("key", ["press", "enter"]),
                generate_event("sleep", 1.0)
            ],
            r"关闭窗口": [
                generate_event("key", ["press", "alt", "f4"])
            ],
            r"输入(.+)": lambda m: [
                generate_event("text", m.group(1))
            ],
            r"点击(.+)按钮": lambda m: [
                generate_event("mouse_move", (500, 300)),  # 示例坐标
                generate_event("mouse_left_click", 1)
            ],
            r"最大化窗口": [
                generate_event("key", ["press", "alt", "space"]),
                generate_event("key", ["press", "x"])
            ]
        }
        
        # 使用正则表达式匹配命令
        import re
        for pattern, actions in command_map.items():
            match = re.match(pattern, text)
            if match:
                if callable(actions):
                    events = actions(match)
                else:
                    events = actions
                
                # 执行生成的事件序列
                for event in events:
                    if isinstance(event, dict) and "type" in event:
                        # 发送事件到KeymouseGo核心
                        Recorder.send_event(event)
                break
        else:
            print(f"[语音识别] 未找到匹配的命令: {text}")

2. 插件注册与加载

修改Plugin/Manager.py文件，确保插件能被正确发现和加载：

# 在discover_plugin方法中添加以下代码
@staticmethod
@logger.catch
def discover_plugin():
    # 原有代码...
    
    # 添加语音识别插件目录到搜索路径
    voice_plugin_path = os.path.join(os.path.dirname(__file__), "VoiceRecognition")
    if voice_plugin_path not in sys.path:
        sys.path.append(voice_plugin_path)
    
    # 原有代码继续...

3. 配置文件实现 (config.py)

import os
from dotenv import load_dotenv

# 加载环境变量
load_dotenv()

class Config:
    # 语音识别配置
    ASR_ENGINE = os.getenv("ASR_ENGINE", "google")  # google, baidu,科大讯飞等
    LANGUAGE = os.getenv("LANGUAGE", "zh-CN")
    ENERGY_THRESHOLD = int(os.getenv("ENERGY_THRESHOLD", 300))
    LISTEN_TIMEOUT = int(os.getenv("LISTEN_TIMEOUT", 5))
    
    # API密钥(用于第三方语音服务)
    BAIDU_APP_ID = os.getenv("BAIDU_APP_ID")
    BAIDU_API_KEY = os.getenv("BAIDU_API_KEY")
    BAIDU_SECRET_KEY = os.getenv("BAIDU_SECRET_KEY")
    
    # 热键配置
    HOTKEY_TOGGLE = os.getenv("HOTKEY_TOGGLE", "f10")
    HOTKEY_CANCEL = os.getenv("HOTKEY_CANCEL", "escape")
    
    # 指令配置
    COMMAND_PREFIX = os.getenv("COMMAND_PREFIX", "")  # 指令前缀，如"小K"

多场景语音控制实现

场景1：文本输入自动化

def handle_text_input(self, text):
    """处理文本输入命令"""
    # 提取需要输入的文本内容
    # 命令格式: "输入[内容]"
    import re
    match = re.match(r"输入(.+)", text)
    if match:
        content = match.group(1)
        events = []
        
        # 1. 确保当前窗口处于激活状态
        events.append({
            "type": "key",
            "action": ["press", "alt", "tab"]
        })
        events.append({
            "type": "sleep",
            "value": 0.5
        })
        
        # 2. 输入文本内容
        events.append({
            "type": "text",
            "value": content
        })
        
        return events
    return None

场景2：应用程序控制

def handle_application_control(self, text):
    """处理应用程序控制命令"""
    app_commands = {
        "记事本": "notepad",
        "计算器": "calc",
        "浏览器": "explorer",
        "任务管理器": "taskmgr",
        "命令提示符": "cmd",
        "画图": "mspaint"
    }
    
    # 命令格式: "打开[应用名称]"
    import re
    match = re.match(r"打开(.+)", text)
    if match:
        app_name = match.group(1)
        if app_name in app_commands:
            return [
                # 打开运行对话框
                {"type": "key", "action": ["press", "meta", "r"]},
                {"type": "sleep", "value": 0.5},
                # 输入应用程序命令
                {"type": "text", "value": app_commands[app_name]},
                {"type": "key", "action": ["press", "enter"]},
                {"type": "sleep", "value": 1.0}
            ]
    
    # 命令格式: "关闭[应用名称]"
    match = re.match(r"关闭(.+)", text)
    if match:
        app_name = match.group(1)
        if app_name in app_commands:
            return [
                # 打开任务管理器
                {"type": "key", "action": ["press", "ctrl", "shift", "esc"]},
                {"type": "sleep", "value": 1.0},
                # 在任务管理器中搜索并结束进程
                {"type": "text", "value": app_name},
                {"type": "key", "action": ["press", "enter"]},
                {"type": "key", "action": ["press", "delete"]},
                {"type": "sleep", "value": 0.5},
                {"type": "key", "action": ["press", "enter"]},
                {"type": "sleep", "value": 0.5},
                {"type": "key", "action": ["press", "alt", "f4"]}
            ]
    
    return None

场景3：快捷键操作

def handle_shortcut_commands(self, text):
    """处理快捷键操作命令"""
    shortcut_map = {
        "复制": ["ctrl", "c"],
        "剪切": ["ctrl", "x"],
        "粘贴": ["ctrl", "v"],
        "撤销": ["ctrl", "z"],
        "重做": ["ctrl", "y"],
        "保存": ["ctrl", "s"],
        "全选": ["ctrl", "a"],
        "查找": ["ctrl", "f"],
        "打印": ["ctrl", "p"],
        "新建": ["ctrl", "n"],
        "关闭窗口": ["alt", "f4"],
        "刷新": ["f5"],
        "截图": ["printscreen"]
    }
    
    # 直接匹配快捷键命令
    if text in shortcut_map:
        return [
            {
                "type": "key",
                "action": ["press"] + shortcut_map[text]
            }
        ]
    
    return None

插件集成与测试

插件安装

# 创建插件目录
mkdir -p Plugin/VoiceRecognition

# 复制插件文件
cp main.py Plugin/VoiceRecognition/
cp manifest.json5 Plugin/VoiceRecognition/
cp config.py Plugin/VoiceRecognition/

# 启动KeymouseGo
python KeymouseGo.py

测试用例设计

测试场景	语音命令	预期结果
文本输入	"输入Hello World"	向当前窗口输入文本"Hello World"
应用控制	"打开记事本"	启动记事本应用程序
快捷键操作	"复制"	执行Ctrl+C操作
窗口操作	"最大化窗口"	当前窗口最大化
错误处理	无意义语音	提示无法识别

常见问题解决

语音识别准确率低
- 解决方案：调整麦克风音量，提高energy_threshold值
- 代码位置：config.py中的ENERGY_THRESHOLD参数
监听超时频繁发生
- 解决方案：延长超时时间，调整timeout参数
- 代码位置：manifest.json5中的timeout设置

中文识别效果不佳

解决方案：切换到百度语音或科大讯飞API
实现示例：

def voice_to_text(self, audio) -> str:
    # 使用百度语音识别API
    from aip import AipSpeech
    config = Config()
    client = AipSpeech(
        config.BAIDU_APP_ID,
        config.BAIDU_API_KEY,
        config.BAIDU_SECRET_KEY
    )
    
    # 音频转码为百度API要求的格式
    audio_data = audio.get_wav_data(convert_rate=16000)
    result = client.asr(audio_data, 'wav', 16000, {
        'dev_pid': 1537,  # 中文普通话
    })
    
    if result.get('err_no') == 0:
        return result.get('result')[0]
    return None

高级功能与扩展思路

1. 自定义命令扩展

创建命令配置文件commands.json：

{
  "自定义命令": [
    {
      "name": "发送邮件",
      "pattern": "发送邮件给张三",
      "actions": [
        {"type": "key", "action": ["press", "meta", "r"]},
        {"type": "text", "value": "outlook"},
        {"type": "key", "action": ["press", "enter"]},
        {"type": "sleep", "value": 3.0},
        {"type": "key", "action": ["press", "ctrl", "n"]},
        {"type": "sleep", "value": 1.0},
        {"type": "text", "value": "zhangsan@example.com"},
        {"type": "key", "action": ["press", "tab"]},
        {"type": "text", "value": "邮件主题"},
        {"type": "key", "action": ["press", "tab"]},
        {"type": "text", "value": "这是一封语音控制发送的邮件"}
      ]
    }
  ]
}

2. 语音唤醒功能

def _wake_word_detection(self, audio):
    """唤醒词检测"""
    wake_words = ["小K小K", "启动命令", "电脑电脑"]
    
    # 使用能量检测快速过滤静音
    if self.recognizer.energy_threshold > 500:
        return False
        
    # 对音频片段进行简单识别
    try:
        text = self.recognizer.recognize_google(audio, language="zh-CN")
        for word in wake_words:
            if word in text:
                print(f"[语音唤醒] 检测到唤醒词: {word}")
                return True
    except:
        pass
        
    return False

3. 多语言支持

def set_language(self, language_code):
    """设置识别语言"""
    language_map = {
        "zh-CN": "中文(简体)",
        "en-US": "英语(美国)",
        "ja-JP": "日语",
        "ko-KR": "韩语",
        "fr-FR": "法语"
    }
    
    if language_code in language_map:
        self.language = language_code
        print(f"[语音识别] 已切换到{language_map[language_code]}")
        return True
    return False