【嵌入式设备】蓝牙鼠标使用教程——遥控器编码值

【嵌入式设备】蓝牙鼠标遥控器-CSDN博客提到绑定操作，其中需要查看遥控器的编码值

以下是使用教程

将以下两段代码上传到设备

ASK_433MHz_Receiver.py

from machine import Pin, Timer
import time

# 配置 GPIO 引脚用于接收 433MHz 射频信号
_ASK_MIN_BYTE_LEN_ = 3                  # 最小字节长度
_ASK_MAX_BYTE_LEN_ = 3                  # 最大字节长度
_ASK_MIN_NEW_FRAM_DETECT_TIME_ = 5000   # 最小帧检测时间间隔（微秒）
_ASK_TOLERANCE_ = 0.9                   # 脉冲宽度的容忍度

# 计算完整的 ASK 数据位长度（16 bits = 2 bytes + 1 start bit）
asklen = (_ASK_MAX_BYTE_LEN_ * 16 + 1)  
datalen_max = (_ASK_MAX_BYTE_LEN_ * 8)  # 射频数据最大位长度
datalen_min = (_ASK_MIN_BYTE_LEN_ * 8)  # 射频数据最小位长度

# 用于检测信号是否开始与结束的标志
detect_begin = False                    # 是否接收到射频开始信号
detect_end = False                      # 射频数据是否接收完成

# 用于存储脉冲时间长度的缓冲区
buffer_int = []
ask_time = 0                            # 记录上一个时间戳（微秒）


# 中断处理器，用于检测 433MHz 射频信号的变化
def irq_handler(pin):
    global buffer_int, ask_time, detect_begin, detect_end
    tackus = time.ticks_us()   # 获取当前时间戳（微秒）

    if not detect_end:  # 如果接收未完成
        dt = time.ticks_diff(tackus, ask_time)  # 计算脉冲间隔
        if not detect_begin:  # 检测是否是新的信号帧
            if dt > _ASK_MIN_NEW_FRAM_DETECT_TIME_ and pin.value():
                detect_begin = True   # 信号开始
                buffer_int = []       # 清空缓冲区
        else:
            if dt > _ASK_MIN_NEW_FRAM_DETECT_TIME_ and pin.value():
                # 如果达到信号结束条件且缓冲区长度符合
                if len(buffer_int) == asklen:
                    detect_end = True
                else:
                    detect_begin = False  # 重置检测开始标志
                    buffer_int = []       # 清空缓冲区
            else:
                buffer_int.append(dt)  # 记录脉冲时间

    ask_time = tackus  # 更新上一个时间戳


# 初始化射频接收引脚
def ask_init(pin):
    rf_pin = Pin(pin, Pin.IN)  # 将指定引脚设为输入模式
    rf_pin.irq(trigger=Pin.IRQ_RISING | Pin.IRQ_FALLING, handler=irq_handler)  # 绑定中断处理器


# 解码逻辑，用于将接收到的脉冲时间转化为字节数据
def decodeData(buffer):
    # 初始化高低电平时间范围
    buffer_time_high = [0, 0]
    buffer_time_low = [0, 0]

    # 判断初始的两个脉冲时间，确定高低电平
    if buffer[0] > buffer[1]:
        buffer_time_high = [buffer[0] - int(_ASK_TOLERANCE_ * buffer[0]), buffer[0] + int(_ASK_TOLERANCE_ * buffer[0])]
        buffer_time_low = [buffer[1] - int(_ASK_TOLERANCE_ * buffer[1]), buffer[1] + int(_ASK_TOLERANCE_ * buffer[1])]
    elif buffer[0] < buffer[1]:
        buffer_time_high = [buffer[1] - int(_ASK_TOLERANCE_ * buffer[1]), buffer[1] + int(_ASK_TOLERANCE_ * buffer[1])]
        buffer_time_low = [buffer[0] - int(_ASK_TOLERANCE_ * buffer[0]), buffer[0] + int(_ASK_TOLERANCE_ * buffer[0])]
    else:
        return None  # 如果两个时间相等，返回 None

    data_bit = 0  # 当前解码的位位置
    data_byte = [0, 0, 0]  # 存储解码后的字节数据
    i = 0
    index = len(buffer)

    # 遍历缓冲区，按位解码数据
    while i < index - 1:
        if (buffer[i] > buffer_time_low[0] and buffer[i] < buffer_time_low[1] and
                buffer[i+1] > buffer_time_high[0] and buffer[i+1] < buffer_time_high[1]):
            data_bit += 1  # 检测到 '0' 位
        elif (buffer[i+1] > buffer_time_low[0] and buffer[i+1] < buffer_time_low[1] and
              buffer[i] > buffer_time_high[0] and buffer[i] < buffer_time_high[1]):
            data_byte[data_bit // 8] |= 0x80 >> (data_bit % 8)  # 设置对应的 '1' 位
            data_bit += 1
        else:
            break  # 遇到无效脉冲对，退出循环

        i += 2  # 每次处理两个脉冲

    # 校验数据位的有效性
    if data_bit % 8 != 0 or data_bit > datalen_max or data_bit < datalen_min:
        return None  # 位数不符合长度要求，返回 None

    return data_byte  # 返回解码后的字节数组


# 接收数据函数，用于检测数据是否接收完成并解码
def reciveData():
    global detect_begin, detect_end, buffer_int
    if detect_end:  # 如果接收结束
        dat = decodeData(buffer_int)
        detect_end = False
        detect_begin = False
        return dat  # 返回解码后的数据
    return None  # 数据未接收完成时返回 None


# 主函数，初始化接收并进入循环
def main():
    global detect_begin, detect_end, buffer_int
    ask_init(16)  # 初始化 GPIO16 引脚为接收引脚

    while True:
        time.sleep_ms(1)  # 短暂延迟，防止 CPU 过载
        if detect_end:  # 检测到接收结束
            print(len(buffer_int), buffer_int)  # 打印缓冲区长度和脉冲时间
            dat = decodeData(buffer_int)
            if dat:  # 打印解码后的字节数据
                print('data:%02x%02x%02x' % (dat[0], dat[1], dat[2]))
            detect_end = False
            detect_begin = False
            time.sleep_ms(100)  # 等待 100 毫秒以防止重复触发

# 入口点，执行主函数
if __name__ == '__main__':
    main()

main.py 

import time
import ASK_433MHz_Receiver
from ASK_433MHz_Receiver import ask_init

def main():
    print("初始化ESP32并连接433MHz接收模块...")
    
    ask_init(16)  # 初始化 433MHz 接收引脚 (GPIO 16)

    print("开始监听遥控信号...")
    
    while True:
        time.sleep(0.1)  # 保持主循环运行，100ms 检查一次
        dat = ASK_433MHz_Receiver.reciveData()  # 接收数据
        if dat:  # 如果数据有效
            print(f"接收到的信号: {dat}")
            print(f"遥控器按键编码: {dat[2]}")  # 打印按键的编码值

if __name__ == "__main__":
    main()

刷新设备，按下遥控器按键，会出现解码

第一位是设备号，第二位是地址，第三位是按键值

每个按键值绑定一套操作逻辑，按下按键即可自动完成一套动作