import serial
import time

# 初始化串口（根据你的实际设备名修改）
ser = serial.Serial(
    port='/dev/ttyUSB0',
    baudrate=9600,  # 设备默认波特率
    parity=serial.PARITY_NONE,
    stopbits=serial.STOPBITS_ONE,
    bytesize=serial.EIGHTBITS,
    timeout=1
)

# 示例：发送鼠标移动指令（相对坐标）
def mouse_move(dx, dy):
    # CH9329 鼠标指令格式（示例，需对照官方协议）
    cmd = b'\x05\x02' + dx.to_bytes(1, 'little', signed=True) + dy.to_bytes(1, 'little', signed=True) + b'\x00'
    ser.write(cmd)
    time.sleep(0.05)

# 示例：发送鼠标左键点击
def mouse_left_click():
    # 按下左键
    ser.write(b'\x05\x01\x01\x00\x00')
    time.sleep(0.05)
    # 释放左键
    ser.write(b'\x05\x01\x00\x00\x00')
    time.sleep(0.05)

# 示例：发送键盘按键（比如按下 'A'）
def key_press(key_code):
    # 按下按键
    ser.write(b'\x04\x00\x00' + key_code + b'\x00\x00\x00\x00')
    time.sleep(0.05)
    # 释放按键
    ser.write(b'\x04\x00\x00\x00\x00\x00\x00\x00')
    time.sleep(0.05)

# 使用示例
mouse_move(100, 50)  # 鼠标向右移动100，向下移动50
mouse_left_click()
key_press(b'\x04')  # 按键 'A' 的 HID 码

import pyperclip
# 新增中文输入方法
def input_chinese(self, text):
    pyperclip.copy(text)  # 主控机写入剪贴板
    time.sleep(0.1)
    self.press_combination(0xE0, 0x19)  # 模拟Ctrl+V粘贴

# 使用示例：直接输入中文，无需任何输入法
ctrl.input_chinese("本次转账金额为伍万元整")

import serial
import time

class CH9329Controller:
    def __init__(self, port='/dev/ttyUSB0', baudrate=9600):
        self.ser = serial.Serial(port, baudrate, timeout=1)
        self.addr = 0x00 # 默认地址

    def _calculate_checksum(self, data):
        """计算累加和校验"""
        return (sum(data)) & 0xFF

    def send_packet(self, cmd, data):
        """组装并发送数据包"""
        length = len(data)
        # 组装帧: HEAD + ADDR + CMD + LEN + DATA + SUM
        packet = [0x57, 0xAB, self.addr, cmd, length] + list(data)
        checksum = self._calculate_checksum(packet)
        packet.append(checksum)
        # 发送字节流
        self.ser.write(bytes(packet))
        time.sleep(0.05) # 必要延时

    # ---------------- 键盘控制 ----------------
    def press_key(self, key_code):
        """按下单个键 (如: ord('a') 或 0x04)"""
        # 数据格式: [0x00, 0x00, 键码, 0, 0, 0, 0, 0]
        data = bytes([0x00, 0x00, key_code & 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00])
        self.send_packet(0x02, data)
        # 释放键
        self.release_all()

    def press_combination(self, modifier_key, key_code):
        """按下组合键 (如: Ctrl+C -> modifier=0xE0, key=0x06)"""
        # 数据格式: [0x00, 0x00, 修饰键, 键码, 0, 0, 0, 0]
        data = bytes([0x00, 0x00, modifier_key & 0xFF, key_code & 0xFF, 0x00, 0x00, 0x00, 0x00])
        self.send_packet(0x02, data)
        self.release_all()

    def release_all(self):
        """释放所有按键"""
        self.send_packet(0x02, bytes([0x00]*8))

    # ---------------- 鼠标控制 ----------------
    def mouse_move(self, dx=0, dy=0, wheel=0):
        """相对移动 (dx, dy) 及滚轮"""
        # 数据格式: 0x01 + 按键(0) + X + Y + 滚轮
        data = bytes([0x01, 0x00, dx & 0xFF, dy & 0xFF, wheel & 0xFF])
        self.send_packet(0x05, data)

    def mouse_click(self, button=0x01):
        """点击 (左键:0x01, 右键:0x02, 中键:0x04)"""
        # 按下
        data_press = bytes([0x01, button, 0x00, 0x00, 0x00])
        self.send_packet(0x05, data_press)
        # 释放
        data_release = bytes([0x01, 0x00, 0x00, 0x00, 0x00])
        self.send_packet(0x05, data_release)

    # ---------------- 多媒体控制 ----------------
    def media_play_pause(self):
        """播放/暂停"""
        self.send_packet(0x03, bytes([0x00, 0xB5]))
        
    def media_volume_up(self):
        """音量加"""
        self.send_packet(0x03, bytes([0x00, 0xE3]))

    def media_volume_down(self):
        """音量减"""
        self.send_packet(0x03, bytes([0x00, 0xE2]))

# --- 使用示例 ---
if __name__ == '__main__':
    # 初始化 (根据你的Ubuntu串口名修改)
    ctrl = CH9329Controller(port='/dev/ttyUSB0')
    
    # 1. 模拟输入 "Hello"
    # HID码: H=0x14, e=0x07, l=0x0F, o=0x13
    print("输入 Hello")
    ctrl.press_key(0x14); ctrl.press_key(0x07); ctrl.press_key(0x0F); ctrl.press_key(0x0F); ctrl.press_key(0x13)
    
    # 2. 模拟 Ctrl+C (复制)
    print("模拟 Ctrl+C")
    ctrl.press_combination(0xE0, 0x06) # 0xE0=左Ctrl, 0x06=C
    
    # 3. 鼠标移动 50, 50 并点击
    print("鼠标移动并点击")
    ctrl.mouse_move(50, 50)
    ctrl.mouse_click(0x01)

from pypinyin import pinyin, Style

# 中文转纯小写拼音串（无空格、无声调）
def ch2pinyin(text):
    pinyin_list = pinyin(text, style=Style.NORMAL, errors='ignore')
    return ''.join([p[0].lower() for p in pinyin_list])

# 测试
print(ch2pinyin("本次金额为1000元"))  # 输出：bencijinewei1000yuan

# 加载区位码对照表，生成字典
def load_qwm_dict(file_path="qwm.txt"):
    qwm_dict = {}
    with open(file_path, 'r', encoding='utf-8') as f:
        for line in f.readlines():
            line = line.strip()
            if not line:
                continue
            char, code = line.split()
            qwm_dict[char] = code
    return qwm_dict

# 中文转区位码串（单个汉字转4位，多汉字拼接）
def ch2qwm(chinese_text, qwm_dict):
    code_str = ""
    for char in chinese_text:
        if char in qwm_dict:
            code_str += qwm_dict[char]
        else:
            print(f"未找到{char}的区位码，跳过")
    return code_str

# 测试
qwm_dict = load_qwm_dict()
print(ch2qwm("金额壹仟元整", qwm_dict))  # 输出：298822275027523751435385

# 新增：模拟按快捷键（切区位码输入法，如Ctrl+Shift+2）
def press_shortcut(self, *keys):
    """按下多键组合，如Ctrl+Shift+2：keys=(0xE0, 0xE1, 0x12)"""
    # 按下所有键
    data = [0x00, 0x00] + list(keys) + [0x00]*(6-len(keys))
    self.send_packet(0x02, bytes(data))
    time.sleep(0.1)
    # 释放所有键
    self.release_all()

# 新增：区位码输入中文
def input_chinese_by_qwm(self, chinese_text, qwm_dict):
    # 1. 切区位码输入法（Ctrl+Shift+2，HID码：0xE0=左Ctrl，0xE1=左Shift，0x12=2）
    self.press_shortcut(0xE0, 0xE1, 0x12)
    # 2. 中文转区位码串
    code_str = ch2qwm(chinese_text, qwm_dict)
    if not code_str:
        return
    # 3. 逐位模拟数字按键（HID码：0=0x27,1=0x1E,2=0x1F,3=0x20,4=0x21,5=0x22,6=0x23,7=0x24,8=0x25,9=0x26）
    num_hid = {'0':0x27, '1':0x1E, '2':0x1F, '3':0x20, '4':0x21, '5':0x22, '6':0x23, '7':0x24, '8':0x25, '9':0x26}
    for num in code_str:
        self.press_key(num_hid[num])
    # 4. 切回原输入法（可选，如Ctrl+Shift+1，根据你的快捷键配置）
    # self.press_shortcut(0xE0, 0xE1, 0x11)

# 使用示例
qwm_dict = load_qwm_dict()
ctrl = CH9329Controller(port='/dev/ttyUSB0')
ctrl.input_chinese_by_qwm("金额壹仟元整", qwm_dict)  # 直接输入中文

import serial
import time
import os

# ---------------- 配置项 ----------------
SERIAL_PORT = "/dev/ttyUSB0"  # 你的串口设备名
# 待测试的波特率列表（覆盖CH9329所有支持值）
BAUD_RATES = [1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200]
# 鼠标左键单击的协议包（已计算校验和：0E）
TEST_PACKET = b'\x57\xAB\x00\x05\x05\x01\x01\x00\x00\x00\x0E'

def set_serial_permission(port):
    """给串口设备赋予读写权限（Ubuntu必要）"""
    try:
        os.system(f"sudo chmod 666 {port}")
        print(f"✅ 已给 {port} 赋予读写权限")
    except Exception as e:
        print(f"❌ 串口权限设置失败：{e}")
        return False
    return True

def test_baudrate(port, baudrate):
    """测试指定波特率，发送鼠标左键单击指令"""
    try:
        # 初始化串口（5秒超时，避免卡死）
        ser = serial.Serial(
            port=port,
            baudrate=baudrate,
            parity=serial.PARITY_NONE,
            stopbits=serial.STOPBITS_ONE,
            bytesize=serial.EIGHTBITS,
            timeout=5
        )
        if not ser.is_open:
            ser.open()
        
        # 发送测试指令（鼠标左键单击）
        ser.write(TEST_PACKET)
        ser.flush()  # 确保数据发送完成
        time.sleep(0.5)  # 给设备响应时间
        
        ser.close()
        return True
    except Exception as e:
        print(f"  ❌ 波特率 {baudrate} 设置失败：{str(e)[:50]}")
        return False

def main():
    # 第一步：设置串口权限
    if not set_serial_permission(SERIAL_PORT):
        return
    
    # 第二步：遍历所有波特率测试
    print("\n=== 开始遍历波特率测试 ===")
    print("⚠️  请紧盯被控端电脑：鼠标左键单击时，对应的波特率就是设备实际波特率！")
    print("-" * 60)
    
    for baud in BAUD_RATES:
        print(f"🔍 测试波特率: {baud} ... ", end="")
        if test_baudrate(SERIAL_PORT, baud):
            print("✅ 已发送测试指令")
        time.sleep(0.1)  # 间隔避免串口占用
    
    # 第三步：提示
    print("\n=== 测试完成 ===")
    print("💡 若被控端鼠标无任何反应：")
    print("  1. 检查CH9329大头是否插在被控电脑（Windows设备管理器看USB键鼠）")
    print("  2. 换被控电脑USB2.0口重试")
    print("  3. 用商家工具重置设备为默认波特率9600")

if __name__ == "__main__":
    # 检查pyserial是否安装
    try:
        import serial
    except ImportError:
        print("❌ 未安装pyserial，先执行：pip install pyserial")
        os.system("pip install pyserial")
        import serial
    
    main()

ser = serial.Serial(
    port="/dev/ttyUSB0",
    baudrate=19200,  # 改为测试出的实际波特率
    parity=serial.PARITY_NONE,
    stopbits=serial.STOPBITS_ONE,
    bytesize=serial.EIGHTBITS,
    timeout=1
)
# 发送任意键鼠指令
ser.write(TEST_PACKET)  # 鼠标左键单击

mouse_click(ser, button=0x02)  # 0x02=右键

def mouse_move(ser, dx, dy):
    """
    鼠标相对移动（dx=X位移，dy=Y位移，范围-128~127）
    原厂P9：位移用补码表示，正数右/下，负数左/上
    """
    # 处理位移范围（原厂限制单步-128~127）
    dx = max(-128, min(127, dx))
    dy = max(-128, min(127, dy))
    # 移动包（无按键，仅位移）
    data_move = [0x01, 0x00, dx & 0xFF, dy & 0xFF, 0x00]
    packet_move = build_packet(ADDR, CMD_MS_REL, data_move)
    # 发送移动+释放（释放包防锁死）
    ser.write(packet_move)
    ser.flush()
    time.sleep(0.05)
    ser.write(build_packet(ADDR, CMD_MS_REL, [0x01, 0x00, 0x00, 0x00, 0x00]))
    ser.flush()
    print(f"✅ 鼠标相对移动：右{dx}像素，下{dy}像素")

# 使用示例（在main中调用）
mouse_move(ser, dx=50, dy=30)  # 右移50，下移30

def key_press(ser, key_code):
    """
    普通键盘按键（单次按下+释放）
    key_code：HID码，比如0x04=A，0x1E=1，0x28=回车，0x2A=退格
    原厂P6：键盘数据格式[0x00,0x00,键码,0x00,0x00,0x00,0x00,0x00]
    """
    # 按下包
    data_press = [0x00, 0x00, key_code, 0x00, 0x00, 0x00, 0x00, 0x00]
    packet_press = build_packet(ADDR, CMD_KB_GENERAL, data_press)
    # 释放包
    data_release = [0x00]*8
    packet_release = build_packet(ADDR, CMD_KB_GENERAL, data_release)
    
    ser.write(packet_press)
    ser.flush()
    time.sleep(0.05)
    ser.write(packet_release)
    ser.flush()
    print(f"✅ 键盘输入：HID码{hex(key_code)}对应的字符")

# 使用示例（在main中调用）
key_press(ser, 0x04)  # 输入A
key_press(ser, 0x1E)  # 输入1
key_press(ser, 0x28)  # 按回车

import serial
import time
import os

# ---------------- 严格按原厂协议配置 ----------------
SERIAL_PORT = "/dev/ttyUSB0"
BAUDRATE = 9600  # 已确认匹配，无需再遍历
FRAME_HEAD = [0x57, 0xAB]  # 原厂固定帧头
ADDR = 0x00  # 原厂默认地址
# 原厂命令码（P5）
CMD_MS_REL = 0x05  # 相对鼠标指令（核心）
CMD_KB_GENERAL = 0x02  # 普通键盘指令

def calculate_checksum(data):
    """原厂协议校验和计算：SUM = 所有字节累加和 % 256（P4）"""
    return sum(data) & 0xFF

def build_packet(addr, cmd, data):
    """按原厂格式组装数据包（P4）：HEAD+ADDR+CMD+LEN+DATA+SUM"""
    len_data = len(data)
    packet = FRAME_HEAD + [addr, cmd, len_data] + data
    checksum = calculate_checksum(packet)
    packet.append(checksum)
    return bytes(packet)

def set_serial_permission(port):
    """Ubuntu串口赋权"""
    try:
        os.system(f"sudo chmod 666 {port}")
        print(f"✅ 已给 {port} 赋权")
    except:
        print("❌ 串口赋权失败")
        return False
    return True

def init_serial(port, baudrate):
    """初始化串口（严格按原厂参数：8位数据/1位停止/无校验）"""
    try:
        ser = serial.Serial(
            port=port,
            baudrate=baudrate,
            parity=serial.PARITY_NONE,
            stopbits=serial.STOPBITS_ONE,
            bytesize=serial.EIGHTBITS,
            timeout=1,
            write_timeout=1
        )
        if not ser.is_open:
            ser.open()
        print(f"✅ 串口初始化成功：{port} @ {baudrate}")
        return ser
    except Exception as e:
        print(f"❌ 串口初始化失败：{e}")
        return None

def mouse_click(ser, button=0x01):
    """
    鼠标单击（严格按原厂P9协议：成对发送按下+释放包）
    button: 0x01=左键（默认），0x02=右键，0x04=中键
    相对鼠标数据格式（P9）：[0x01, 按键码, X位移, Y位移, 滚轮]
    """
    # 1. 鼠标按下包（X/Y/滚轮均为0，仅按下按键）
    data_press = [0x01, button, 0x00, 0x00, 0x00]
    packet_press = build_packet(ADDR, CMD_MS_REL, data_press)
    # 2. 鼠标释放包（按键码为0，释放所有键）
    data_release = [0x01, 0x00, 0x00, 0x00, 0x00]
    packet_release = build_packet(ADDR, CMD_MS_REL, data_release)
    
    # 成对发送（原厂强制要求，间隔100ms）
    ser.write(packet_press)
    ser.flush()
    time.sleep(0.1)
    ser.write(packet_release)
    ser.flush()
    time.sleep(0.1)
    print(f"✅ 鼠标{('左键','右键','中键')[button//2]}单击指令发送完成（成对）")

def release_all(ser):
    """释放所有键鼠（发送空包，防止锁死）"""
    # 鼠标释放
    data_ms = [0x01, 0x00, 0x00, 0x00, 0x00]
    ser.write(build_packet(ADDR, CMD_MS_REL, data_ms))
    # 键盘释放
    data_kb = [0x00]*8
    ser.write(build_packet(ADDR, CMD_KB_GENERAL, data_kb))
    ser.flush()
    print("✅ 已发送释放指令，防止键鼠锁死")

def main():
    # 步骤1：赋权+初始化串口
    if not set_serial_permission(SERIAL_PORT):
        return
    ser = init_serial(SERIAL_PORT, BAUDRATE)
    if not ser:
        return
    
    # 步骤2：先释放所有键鼠，防止初始锁死
    release_all(ser)
    
    # 步骤3：发送鼠标左键单击（核心测试，成对指令）
    print("\n🔍 开始发送鼠标左键单击指令（严格按原厂协议）")
    mouse_click(ser, button=0x01)
    
    # 步骤4：再次释放+关闭串口
    release_all(ser)
    ser.close()
    print("\n✅ 测试完成，串口已关闭，鼠标不会锁死")

if __name__ == "__main__":
    # 检查pyserial
    try:
        import serial
    except ImportError:
        print("❌ 未安装pyserial，执行：pip install pyserial")
        os.system("pip install pyserial")
        import serial
    main()

import serial
import time
import os
import sys
import signal

# -------------------------- 核心配置（不变） --------------------------
SERIAL_PORT = "/dev/ttyUSB0"
BAUDRATE = 9600
FRAME_HEAD = [0x57, 0xAB]
ADDR = 0x00
CMD_KB_GENERAL = 0x02

HID_CODE = {
    "U": 0x18, "0": 0x27, "1": 0x1E, "2": 0x1F, "3": 0x20,
    "4": 0x21, "5": 0x22, "6": 0x23, "7": 0x24, "8": 0x25, "9": 0x26,
    "A": 0x04, "B": 0x05, "C": 0x06, "D": 0x07, "E": 0x08, "F": 0x09,
    "SPACE": 0x2C
}
MOD_KEY = {
    "LCTRL": 0x01,
    "LSHIFT": 0x02
}

# 全局变量（不变）
ser = None
is_key_held = False

# -------------------------- 核心方法（不变） --------------------------
def calculate_checksum(data):
    return sum(data) & 0xFF

def build_packet(addr, cmd, data):
    len_data = len(data)
    packet = FRAME_HEAD + [addr, cmd, len_data] + data
    packet.append(calculate_checksum(packet))
    return bytes(packet)

def set_serial_permission(port):
    try:
        os.system(f"sudo chmod 666 {port} > /dev/null 2>&1")
        return True
    except:
        print("❌ 串口赋权失败，请手动执行：sudo chmod 666 /dev/ttyUSB0")
        return False

def init_serial(port, baudrate):
    global ser
    try:
        ser = serial.Serial(
            port=port, baudrate=baudrate,
            parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, bytesize=serial.EIGHTBITS,
            timeout=1, write_timeout=1
        )
        if not ser.is_open:
            ser.open()
        return True
    except Exception as e:
        print(f"❌ 串口初始化失败：{str(e)[:50]}")
        return False

def force_release_all():
    global ser, is_key_held
    if ser and ser.is_open and is_key_held:
        try:
            release_pkt = build_packet(ADDR, CMD_KB_GENERAL, [0x00]*8)
            ser.write(release_pkt)
            ser.flush()
            time.sleep(0.05)
            is_key_held = False
            print("✅ 【强制释放】所有修饰键已复原")
        except:
            pass
    elif ser and ser.is_open:
        print("✅ 无按住的修饰键，无需释放")

def mod_key_hold(ser, mod_list):
    global is_key_held
    mod_mask = 0
    for mod in mod_list:
        mod_mask |= MOD_KEY[mod]
    data = [mod_mask, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
    ser.write(build_packet(ADDR, CMD_KB_GENERAL, data))
    ser.flush()
    time.sleep(0.05)
    is_key_held = True
    print(f"🔹 按住修饰键：{'+'.join(mod_list)}（掩码：0x{mod_mask:02X}）")

def common_key_tap(ser, key_name):
    hid = HID_CODE[key_name]
    ser.write(build_packet(ADDR, CMD_KB_GENERAL, [0x00, 0x00, hid, 0x00, 0x00, 0x00, 0x00, 0x00]))
    ser.flush()
    time.sleep(0.03)
    ser.write(build_packet(ADDR, CMD_KB_GENERAL, [0x00]*8))
    ser.flush()
    time.sleep(0.03)
    print(f"🔹 敲击普通键：{key_name}（HID码：0x{hid:02X}）")

def mod_key_release(ser):
    global is_key_held
    if is_key_held:
        ser.write(build_packet(ADDR, CMD_KB_GENERAL, [0x00]*8))
        ser.flush()
        time.sleep(0.05)
        is_key_held = False
        print("🔹 松开所有修饰键")

def signal_handler(signum, frame):
    print(f"\n⚠️  捕获到中断信号，正在强制释放所有键...")
    force_release_all()
    if ser and ser.is_open:
        ser.close()
    print("✅ 串口已关闭，程序安全退出")
    sys.exit(0)

signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)

def unicode2ubuntu(unicode_hex):
    global ser
    if not ser or not ser.is_open:
        print("❌ 串口未就绪，无法执行输入")
        return False
    try:
        mod_key_hold(ser, ["LCTRL", "LSHIFT"])
        common_key_tap(ser, "U")
        mod_key_release(ser)
        for c in unicode_hex.upper():
            common_key_tap(ser, c)
        common_key_tap(ser, "SPACE")
        time.sleep(0.1)
        print(f"✅ Unicode码点【{unicode_hex}】输入完成\n")
        return True
    except Exception as e:
        print(f"❌ 码点【{unicode_hex}】输入失败：{str(e)[:50]}")
        force_release_all()
        return False

# -------------------------- 主程序（核心修改：延时切焦点） --------------------------
def main():
    global ser
    print("=====================================")
    print("✅ 本机单键盘版 CH9329 Ubuntu22.04 Demo")
    print("📌 输入目标：中国（中=4E2D | 国=56FD）")
    print("📌 操作逻辑：启动后延时5秒，你切焦点到记事本/输入框")
    print("=====================================\n")

    if not set_serial_permission(SERIAL_PORT):
        return
    if not init_serial(SERIAL_PORT, BAUDRATE):
        return
    print(f"✅ 串口准备完成：{SERIAL_PORT} @ {BAUDRATE}\n")

    # 核心修改：去掉回车，改为延时5秒
    print("📢 脚本将在【5秒后自动执行】，请立即点击记事本/输入框（光标闪烁）！")
    for i in range(5, 0, -1):
        print(f"⏳ 倒计时：{i}秒")
        time.sleep(1)
    print("\n🔍 开始执行Unicode输入操作...\n")

    try:
        unicode2ubuntu("4E2D")
        unicode2ubuntu("56FD")
        print("🎉 所有输入操作执行完成！")
        print("📌 查看目标输入框，应显示【中国】二字")
    except Exception as e:
        print(f"\n❌ 程序执行异常：{str(e)[:50]}")
    finally:
        print("\n🔐 最终兜底：强制释放所有键 + 关闭串口...")
        force_release_all()
        if ser and ser.is_open:
            ser.close()
            print("✅ 串口已安全关闭")
        print("✅ 程序完全退出，键盘无任何锁死风险！")

if __name__ == "__main__":
    main()

# 仅修改main函数，其他代码和方案1完全一致
def main():
    global ser
    print("=====================================")
    print("✅ 自动切焦点版 CH9329 Ubuntu22.04 Demo")
    print("📌 输入目标：中国（中=4E2D | 国=56FD）")
    print("📌 操作逻辑：自动打开记事本+激活焦点，无需手动操作")
    print("=====================================\n")

    # 第一步：自动打开Ubuntu记事本（gedit）
    try:
        os.system("gedit &")  # 后台打开记事本
        time.sleep(2)  # 等待记事本启动
        print("✅ 已自动打开记事本（gedit）")
    except:
        print("❌ 自动打开记事本失败，请手动打开")

    # 后续步骤和方案1一致（串口初始化+延时+执行）
    if not set_serial_permission(SERIAL_PORT):
        return
    if not init_serial(SERIAL_PORT, BAUDRATE):
        return
    print(f"✅ 串口准备完成：{SERIAL_PORT} @ {BAUDRATE}\n")

    print("📢 脚本将在【3秒后自动执行】，无需手动操作！")
    for i in range(3, 0, -1):
        print(f"⏳ 倒计时：{i}秒")
        time.sleep(1)
    print("\n🔍 开始执行Unicode输入操作...\n")

    try:
        unicode2ubuntu("4E2D")
        unicode2ubuntu("56FD")
        print("🎉 所有输入操作执行完成！")
        print("📌 查看自动打开的记事本，应显示【中国】二字")
    except Exception as e:
        print(f"\n❌ 程序执行异常：{str(e)[:50]}")
    finally:
        print("\n🔐 最终兜底：强制释放所有键 + 关闭串口...")
        force_release_all()
        if ser and ser.is_open:
            ser.close()
            print("✅ 串口已安全关闭")
        print("✅ 程序完全退出，键盘无任何锁死风险！")

import serial
import time
import os
import sys
import signal

# -------------------------- 核心配置 --------------------------
SERIAL_PORT = "/dev/ttyUSB0"
BAUDRATE = 9600
FRAME_HEAD = [0x57, 0xAB]
ADDR = 0x00
CMD_KB_GENERAL = 0x02

# HID码表（补充Enter键）
HID_CODE = {
    "U": 0x18, "0": 0x27, "1": 0x1E, "2": 0x1F, "3": 0x20,
    "4": 0x21, "5": 0x22, "6": 0x23, "7": 0x24, "8": 0x25, "9": 0x26,
    "A": 0x04, "B": 0x05, "C": 0x06, "D": 0x07, "E": 0x08, "F": 0x09,
    "SPACE": 0x2C, "ENTER": 0x28
}
# 修饰键掩码
MOD_KEY = {
    "LCTRL": 0x01,
    "LSHIFT": 0x02
}

# 全局变量
ser = None
is_key_held = False

# -------------------------- CH9329协议核心 --------------------------
def calculate_checksum(data):
    return sum(data) & 0xFF

def build_packet(addr, cmd, data):
    len_data = len(data)
    packet = FRAME_HEAD + [addr, cmd, len_data] + data
    packet.append(calculate_checksum(packet))
    return bytes(packet)

def set_serial_permission(port):
    try:
        os.system(f"sudo chmod 666 {port} > /dev/null 2>&1")
        return True
    except:
        print("❌ 串口赋权失败，请手动执行：sudo chmod 666 /dev/ttyUSB0")
        return False

def init_serial(port, baudrate):
    global ser
    try:
        ser = serial.Serial(
            port=port, baudrate=baudrate,
            parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, bytesize=serial.EIGHTBITS,
            timeout=1, write_timeout=1
        )
        if not ser.is_open:
            ser.open()
        return True
    except Exception as e:
        print(f"❌ 串口初始化失败：{str(e)[:50]}")
        return False

# -------------------------- 核心释放/模拟方法 --------------------------
def force_release_all():
    global ser, is_key_held
    if ser and ser.is_open:
        try:
            release_pkt = build_packet(ADDR, CMD_KB_GENERAL, [0x00]*8)
            ser.write(release_pkt)
            ser.flush()
            time.sleep(0.05)
            is_key_held = False
            print("✅ 所有按键已强制释放")
        except:
            pass

def mod_key_release(ser):
    global is_key_held
    if ser and ser.is_open:
        ser.write(build_packet(ADDR, CMD_KB_GENERAL, [0x00]*8))
        ser.flush()
        time.sleep(0.05)
        is_key_held = False

def common_key_tap(ser, key_name):
    if key_name not in HID_CODE:
        return
    hid = HID_CODE[key_name]
    # 按下
    ser.write(build_packet(ADDR, CMD_KB_GENERAL, [0x00, 0x00, hid, 0x00, 0x00, 0x00, 0x00, 0x00]))
    ser.flush()
    time.sleep(0.02)
    # 松开
    ser.write(build_packet(ADDR, CMD_KB_GENERAL, [0x00]*8))
    ser.flush()
    time.sleep(0.02)

# -------------------------- Gemini核心逻辑的unicode2ubuntu --------------------------
def unicode2ubuntu(unicode_hex):
    global ser
    if not ser or not ser.is_open:
        print("❌ 串口未就绪")
        return False
    
    try:
        # --- 步骤 1: 按住Ctrl+Shift（掩码不中断） ---
        mod_mask = MOD_KEY["LCTRL"] | MOD_KEY["LSHIFT"]
        ser.write(build_packet(ADDR, CMD_KB_GENERAL, [mod_mask, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]))
        ser.flush()
        time.sleep(0.1)  # 等待系统识别组合键

        # --- 步骤 2: 按住Ctrl+Shift敲U键 ---
        u_hid = HID_CODE["U"]
        # 按下U（仍带修饰键掩码）
        ser.write(build_packet(ADDR, CMD_KB_GENERAL, [mod_mask, 0x00, u_hid, 0x00, 0x00, 0x00, 0x00, 0x00]))
        ser.flush()
        time.sleep(0.05)
        # 松开U（保留修饰键掩码）
        ser.write(build_packet(ADDR, CMD_KB_GENERAL, [mod_mask, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]))
        ser.flush()
        time.sleep(0.1)  # 此时屏幕应出现带下划线的u

        # --- 步骤 3: 松开修饰键，输入码点 ---
        mod_key_release(ser)
        time.sleep(0.05)

        for c in unicode_hex.upper():
            if c in HID_CODE:
                common_key_tap(ser, c)
                time.sleep(0.02)

        # --- 步骤 4: 按Enter确认 ---
        enter_hid = HID_CODE["ENTER"]
        ser.write(build_packet(ADDR, CMD_KB_GENERAL, [0x00, 0x00, enter_hid, 0x00, 0x00, 0x00, 0x00, 0x00]))
        ser.flush()
        time.sleep(0.02)
        ser.write(build_packet(ADDR, CMD_KB_GENERAL, [0x00]*8))
        ser.flush()
        
        print(f"✅ Unicode码点【{unicode_hex}】发送成功")
        return True
    except Exception as e:
        print(f"❌ 执行失败：{str(e)}")
        force_release_all()
        return False

# -------------------------- 信号捕获+主程序 --------------------------
def signal_handler(signum, frame):
    print(f"\n⚠️  捕获中断信号，释放所有键...")
    force_release_all()
    if ser and ser.is_open:
        ser.close()
    sys.exit(0)

signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)

def main():
    global ser
    print("=====================================")
    print("✅ Gemini逻辑版 CH9329 Ubuntu Unicode Demo")
    print("=====================================\n")

    if not set_serial_permission(SERIAL_PORT):
        return
    if not init_serial(SERIAL_PORT, BAUDRATE):
        return

    # 5秒延时切焦点
    print("📢 5秒后自动执行，请切焦点到输入框！")
    for i in range(5, 0, -1):
        print(f"⏳ {i}秒")
        time.sleep(1)

    # 输入“中国”
    unicode2ubuntu("4E2D")  # 中
    unicode2ubuntu("56FD")  # 国

    # 最终兜底
    force_release_all()
    if ser and ser.is_open:
        ser.close()
    print("\n🎉 执行完成，串口已关闭！")

if __name__ == "__main__":
    main()

import serial
import time
import os
import sys
import signal

# -------------------------- 核心配置 --------------------------
SERIAL_PORT = "/dev/ttyUSB0"
BAUDRATE = 9600
FRAME_HEAD = [0x57, 0xAB]
ADDR = 0x00
CMD_KB_GENERAL = 0x02

# HID码表（补充ESC/CapsLock/Super键，适配输入法复位）
HID_CODE = {
    # 基础键
    "U": 0x18, "0": 0x27, "1": 0x1E, "2": 0x1F, "3": 0x20,
    "4": 0x21, "5": 0x22, "6": 0x23, "7": 0x24, "8": 0x25, "9": 0x26,
    "A": 0x04, "B": 0x05, "C": 0x06, "D": 0x07, "E": 0x08, "F": 0x09,
    # 功能键
    "SPACE": 0x2C, "ENTER": 0x28, "ESC": 0x29, "CAPSLOCK": 0x39,
    "LSHIFT": 0x2A, "LSUPER": 0x38  # LSUPER=Win/Super键
}
# 修饰键掩码
MOD_KEY = {
    "LCTRL": 0x01,
    "LSHIFT": 0x02,
    "LSUPER": 0x08  # Super键掩码（原厂P6定义）
}

# 全局变量
ser = None
is_key_held = False

# -------------------------- CH9329协议核心 --------------------------
def calculate_checksum(data):
    return sum(data) & 0xFF

def build_packet(addr, cmd, data):
    len_data = len(data)
    packet = FRAME_HEAD + [addr, cmd, len_data] + data
    packet.append(calculate_checksum(packet))
    return bytes(packet)

def set_serial_permission(port):
    try:
        os.system(f"sudo chmod 666 {port} > /dev/null 2>&1")
        return True
    except:
        print("❌ 串口赋权失败，请手动执行：sudo chmod 666 /dev/ttyUSB0")
        return False

def init_serial(port, baudrate):
    global ser
    try:
        ser = serial.Serial(
            port=port, baudrate=baudrate,
            parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, bytesize=serial.EIGHTBITS,
            timeout=1, write_timeout=1
        )
        if not ser.is_open:
            ser.open()
        return True
    except Exception as e:
        print(f"❌ 串口初始化失败：{str(e)[:50]}")
        return False

# -------------------------- 输入法干扰处理核心方法 --------------------------
def reset_input_method():
    """
    硬件级复位输入法状态（三重保障）：
    1. ESC清除输入法缓冲区 2. Win+Space切换输入法 3. CapsLock开启大写锁定
    """
    global ser
    if not ser or not ser.is_open:
        return
    
    print("🔧 开始复位输入法状态...")
    # 1. 敲ESC，清除输入法残余缓冲区
    esc_hid = HID_CODE["ESC"]
    ser.write(build_packet(ADDR, CMD_KB_GENERAL, [0x00, 0x00, esc_hid, 0x00, 0x00, 0x00, 0x00, 0x00]))
    ser.flush()
    time.sleep(0.05)
    ser.write(build_packet(ADDR, CMD_KB_GENERAL, [0x00]*8))
    ser.flush()
    time.sleep(0.1)

    # 2. 发送Win+Space（Ubuntu切换输入法快捷键）
    super_mask = MOD_KEY["LSUPER"]
    # 按住Win键
    ser.write(build_packet(ADDR, CMD_KB_GENERAL, [super_mask, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]))
    ser.flush()
    time.sleep(0.05)
    # 敲Space
    space_hid = HID_CODE["SPACE"]
    ser.write(build_packet(ADDR, CMD_KB_GENERAL, [super_mask, 0x00, space_hid, 0x00, 0x00, 0x00, 0x00, 0x00]))
    ser.flush()
    time.sleep(0.05)
    ser.write(build_packet(ADDR, CMD_KB_GENERAL, [super_mask, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]))
    ser.flush()
    time.sleep(0.05)
    # 松开Win键
    ser.write(build_packet(ADDR, CMD_KB_GENERAL, [0x00]*8))
    ser.flush()
    time.sleep(0.1)

    # 3. 开启CapsLock（大写锁定穿透输入法）
    caps_hid = HID_CODE["CAPSLOCK"]
    ser.write(build_packet(ADDR, CMD_KB_GENERAL, [0x00, 0x00, caps_hid, 0x00, 0x00, 0x00, 0x00, 0x00]))
    ser.flush()
    time.sleep(0.05)
    ser.write(build_packet(ADDR, CMD_KB_GENERAL, [0x00]*8))
    ser.flush()
    time.sleep(0.1)
    print("✅ 输入法状态复位完成（大写锁定已开启）")

def restore_capslock():
    """输入完成后还原CapsLock状态"""
    global ser
    if not ser or not ser.is_open:
        return
    print("🔧 还原大写锁定状态...")
    caps_hid = HID_CODE["CAPSLOCK"]
    ser.write(build_packet(ADDR, CMD_KB_GENERAL, [0x00, 0x00, caps_hid, 0x00, 0x00, 0x00, 0x00, 0x00]))
    ser.flush()
    time.sleep(0.05)
    ser.write(build_packet(ADDR, CMD_KB_GENERAL, [0x00]*8))
    ser.flush()
    time.sleep(0.1)
    print("✅ 大写锁定已还原")

# -------------------------- 核心释放方法 --------------------------
def force_release_all():
    global ser, is_key_held
    if ser and ser.is_open:
        try:
            release_pkt = build_packet(ADDR, CMD_KB_GENERAL, [0x00]*8)
            ser.write(release_pkt)
            ser.flush()
            time.sleep(0.05)
            is_key_held = False
            print("✅ 所有按键已强制释放")
        except:
            pass

# -------------------------- Gemini优化版Unicode输入 --------------------------
def unicode2ubuntu(unicode_hex):
    global ser
    if not ser or not ser.is_open:
        print("❌ 串口未就绪")
        return False
    
    try:
        # --- 步骤 1: 全程按住Ctrl+Shift（优先级高于输入法） ---
        mod_mask = MOD_KEY["LCTRL"] | MOD_KEY["LSHIFT"]
        ser.write(build_packet(ADDR, CMD_KB_GENERAL, [mod_mask, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]))
        ser.flush()
        time.sleep(0.1)  # 等待系统识别组合键（优先级高于输入法）

        # --- 步骤 2: 按住Ctrl+Shift敲U键（大写U穿透输入法） ---
        u_hid = HID_CODE["U"]
        # 按下U（仍带修饰键掩码）
        ser.write(build_packet(ADDR, CMD_KB_GENERAL, [mod_mask, 0x00, u_hid, 0x00, 0x00, 0x00, 0x00, 0x00]))
        ser.flush()
        time.sleep(0.05)
        # 松开U（保留修饰键掩码）
        ser.write(build_packet(ADDR, CMD_KB_GENERAL, [mod_mask, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]))
        ser.flush()
        time.sleep(0.1)  # 此时屏幕出现带下划线的u，输入法已被绕过

        # --- 步骤 3: 输入码点（大写锁定+修饰键双重保障） ---
        for c in unicode_hex.upper():
            if c in HID_CODE:
                # 每个字符都带修饰键掩码，彻底绕过输入法
                char_hid = HID_CODE[c]
                ser.write(build_packet(ADDR, CMD_KB_GENERAL, [mod_mask, 0x00, char_hid, 0x00, 0x00, 0x00, 0x00, 0x00]))
                ser.flush()
                time.sleep(0.02)
                ser.write(build_packet(ADDR, CMD_KB_GENERAL, [mod_mask, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]))
                ser.flush()
                time.sleep(0.02)

        # --- 步骤 4: 按Enter确认（仍带修饰键掩码） ---
        enter_hid = HID_CODE["ENTER"]
        ser.write(build_packet(ADDR, CMD_KB_GENERAL, [mod_mask, 0x00, enter_hid, 0x00, 0x00, 0x00, 0x00, 0x00]))
        ser.flush()
        time.sleep(0.02)
        ser.write(build_packet(ADDR, CMD_KB_GENERAL, [mod_mask, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]))
        ser.flush()
        time.sleep(0.05)

        # --- 步骤 5: 释放所有修饰键 ---
        force_release_all()
        print(f"✅ Unicode码点【{unicode_hex}】发送成功（已绕过输入法）")
        return True
    except Exception as e:
        print(f"❌ 执行失败：{str(e)}")
        force_release_all()
        return False

# -------------------------- 信号捕获+主程序 --------------------------
def signal_handler(signum, frame):
    print(f"\n⚠️  捕获中断信号，释放所有键...")
    force_release_all()
    restore_capslock()  # 还原大写锁定
    if ser and ser.is_open:
        ser.close()
    sys.exit(0)

signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)

def main():
    global ser
    print("=====================================")
    print("✅ 防输入法干扰版 CH9329 Unicode Demo")
    print("📌 核心：自动复位输入法+大写锁定+全程修饰键")
    print("=====================================\n")

    # 串口初始化
    if not set_serial_permission(SERIAL_PORT):
        return
    if not init_serial(SERIAL_PORT, BAUDRATE):
        return

    # 5秒延时切焦点
    print("📢 5秒后自动执行，请切焦点到输入框！")
    for i in range(5, 0, -1):
        print(f"⏳ {i}秒")
        time.sleep(1)

    # 核心步骤：1.复位输入法 2.执行Unicode输入 3.还原状态
    reset_input_method()
    unicode2ubuntu("4E2D")  # 中
    unicode2ubuntu("56FD")  # 国
    restore_capslock()

    # 最终兜底
    force_release_all()
    if ser and ser.is_open:
        ser.close()
    print("\n🎉 执行完成！无需切换英文，直接输出中文！")

if __name__ == "__main__":
    main()