smartpi 0.1.0__py3-none-any.whl

smartpi/__init__.py

@@ -0,0 +1,4 @@
+from smartpi import module
+
+__version__ = "0.1.0"
+

smartpi/app_module.py

@@ -0,0 +1,119 @@
+# coding=utf-8
+import time
+from typing import List, Optional
+from smartpi.module import Uart3_funtions,base_driver
+
+
+class app_funtion:
+    #马达编码读取 port:连接M端口；
+    def read_motor_code(port:bytes) -> Optional[bytes]:
+        motor_str=[0xA0, 0x01, 0x01, 0xBE]           
+        motor_str[0]=0XA0+port       
+        response = Uart3_funtions.single_operate_sensor(motor_str)
+        if response:
+            return 0
+        else:
+            return -1
+            
+    #马达速度控制 port:连接M端口；speed:0~100
+    def write_motor_speed(port:bytes,speed:bytes) -> Optional[bytes]:
+        motor_str=[0xA0, 0x01, 0x02, 0x71, 0x00, 0xBE]           
+        motor_str[0]=0XA0+port
+        motor_str[4]=speed
+        response = Uart3_funtions.single_operate_sensor(motor_str)
+        if response:
+            return 0
+        else:
+            return -1
+            
+    #马达速度编码控制 port:连接M端口；speed:0~100；code:0~65535
+    def motor_servoctl(port:bytes,speed:bytes,code:int) -> Optional[bytes]:
+        motor_str=[0xA0, 0x01, 0x04, 0x81, 0x00, 0x81, 0x00, 0x00, 0xBE]           
+        motor_str[0]=0XA0+port
+        motor_str[4]=speed
+        motor_str[6]=code//256
+        motor_str[7]=code%256
+        response = Uart3_funtions.single_operate_sensor(motor_str)
+        if response:
+            return 0
+        else:
+            return -1
+            
+    #马达方向控制 port:连接M端口；dir:
+    def write_motor_dir(port:bytes,direc:bytes) -> Optional[bytes]:
+        motor_str=[0xA0, 0x01, 0x06, 0x71, 0x00, 0xBE]           
+        motor_str[0]=0XA0+port
+        motor_str[4]=direc
+        response = Uart3_funtions.single_operate_sensor(motor_str)
+        if response:
+            return 0
+        else:
+            return -1
+
+    #彩灯控制 port:连接P端口；command:0:关灯；1:红；2:绿；3:蓝；4:黄；5:紫；6:青；7:白
+    def color_lamp_operate(port:bytes,command:bytes) -> Optional[bytes]:
+        color_lamp_str=[0xA0, 0x05, 0x00, 0xBE]
+        color_lamp_str[0]=0XA0+port
+        color_lamp_str[2]=command
+        response = Uart3_funtions.single_operate_sensor(color_lamp_str)
+        if response:
+            return 0
+        else:
+            return -1
+        
+    #触碰传感器 port:连接P端口
+    def read_switch(port:bytes) -> Optional[bytes]:
+        read_sw_str=[0xA0, 0x03, 0x01, 0xBE]
+        read_sw_str[0]=0XA0+port   
+        response = Uart3_funtions.single_operate_sensor(read_sw_str)
+        if response:
+            return 0
+        else:
+            return -1
+            
+    #光电读取 port:连接P端口；command:1:读取；2:开灯；3:关灯；
+    def light_operate(port:bytes,command:bytes) -> Optional[bytes]:
+        light_str=[0xA0, 0x02, 0x00, 0xBE]
+        light_str[0]=0XA0+port
+        light_str[2]=command 
+        response = Uart3_funtions.single_operate_sensor(light_str)
+        if response:
+            return 0
+        else:
+            return -1
+
+    #温湿度读取 port:连接P端口；command:0:读取湿度；1:读取温度；
+    def humiture_operate(port:bytes,command:bytes) -> Optional[bytes]:
+        humiture_str=[0xA0, 0x0C, 0x01, 0x71, 0x00, 0xBE]
+        humiture_str[0]=0XA0+port
+        humiture_str[2]=command 
+        response = Uart3_funtions.single_operate_sensor(humiture_str)
+        if response:
+            return 0
+        else:
+            return -1
+
+    #超声波读取 port:连接P端口；command:1:读取；
+    def ultrasonic_operate(port:bytes,command:bytes) -> Optional[bytes]:
+        ultrasonic_str=[0xA0, 0x06, 0x00, 0xBE]
+        ultrasonic_str[0]=0XA0+port
+        ultrasonic_str[2]=command 
+        response = Uart3_funtions.single_operate_sensor(ultrasonic_str)
+        if response:
+            return 0
+        else:
+            return -1
+            
+    #舵机控制 port:连接P端口；command:
+    def servo_operate(port:bytes,command:bytes,angle:bytes) -> Optional[bytes]:
+        servo_str=[0xA0, 0x0E, 0x01, 0x71, 0x00, 0xBE]
+        servo_str[0]=0XA0+port
+        servo_str[2]=command
+        servo_str[4]=angle
+        response = Uart3_funtions.single_operate_sensor(servo_str)
+        if response:
+            return 0
+        else:
+            return -1
+
+

smartpi/module.py

@@ -0,0 +1,503 @@
+# coding=utf-8
+import serial,time,struct
+from typing import List, Optional
+from collections import deque
+
+
+# 命令常量
+BOOT_UPDATE_H = 0XFF
+BOOT_UPDATE_L = 0XFF
+READ_MODEL_H = 0XFF
+READ_MODEL_L = 0X01
+READ_VERSION_H = 0XFF
+READ_VERSION_L = 0X02
+READ_FACTORY_H = 0XFF
+READ_FACTORY_L = 0X03
+READ_HW_ID_H = 0XFF
+READ_HW_ID_L = 0X04
+READ_NAME_H = 0XFF
+READ_NAME_L = 0X05
+WRITE_NAME_H = 0XFF
+WRITE_NAME_L = 0X06
+READ_CONNECT_H = 0XFF
+READ_CONNECT_L = 0X07
+READ_BAT_H = 0XFF
+READ_BAT_L = 0X0C
+
+UPDATE_REQUEST_H = 0XFF
+UPDATE_REQUEST_L = 0X10
+MAX_COM_LEN_H = 0XFF
+MAX_COM_LEN_L = 0X11
+DL_MESSAGE_H = 0XFF
+DL_MESSAGE_L = 0X12
+READ_STATUS_H = 0XFF
+READ_STATUS_L = 0X13
+PAGE_CHECK_H = 0XFF
+PAGE_CHECK_L = 0X14
+PAGE_SEND_H = 0XFF
+PAGE_SEND_L = 0X15
+
+READ_PERIPH_H = 0X01
+READ_PERIPH_L = 0X01
+SINGLE_OP_H = 0X01
+SINGLE_OP_L = 0X02
+MODE_CHANGE_H = 0X01
+MODE_CHANGE_L = 0X03
+SEND_CYCLE_H = 0X01
+SEND_CYCLE_L = 0X04
+
+frames_queue = deque()
+buffer = bytearray()
+HEADER = bytes.fromhex('86 AB')  # 帧头
+FOOTER = bytes.fromhex('CF')     # 帧尾
+MIN_FRAME_LEN = 9                # 最小帧长度
+
+# 串口配置参数
+SERIAL_PORT = "/dev/ttyS3"  # 串口设备路径
+BAUD_RATE = 115200          # 波特率
+TIMEOUT = 0.1                # 读取超时时间（秒）
+
+ser = serial.Serial(
+            port=SERIAL_PORT,
+            baudrate=BAUD_RATE,
+            bytesize=serial.EIGHTBITS,  # 8位数据位
+            parity=serial.PARITY_NONE,  # 无校验位
+            stopbits=serial.STOPBITS_ONE,  # 1位停止位
+            timeout=TIMEOUT,
+            xonxoff=False,  # 关闭软件流控
+            rtscts=False,   # 关闭硬件流控
+        
+        )
+
+class base_driver:
+    def uart3_init() -> Optional[serial.Serial]:
+        """初始化串口"""
+        try:        
+            if ser.is_open:
+                print("UART3初始化成功")
+                return ser
+            else:
+                print("Error opening UART3")
+                return None
+        except Exception as e:
+            print(f"Error opening UART3: {e}")
+            return None
+
+    def calculate_pro_check(command_h: int, command_l: int, data: List[bytes] = None) -> int:    
+        if data:
+            len_data = len(data)
+            base_sum = 0x86 + 0xAB + 0x00 + 0x09 + len_data + command_h + command_l + 0x01 + 0xCF
+            base_sum += sum(data)
+        else:
+            base_sum = 0x86 + 0xAB + 0x00 + 0x09 + command_h + command_l + 0x01 + 0xCF
+            
+        return base_sum % 256  # 确保结果为单字节（原C代码未取模，需根据实际协议调整）
+    
+    def write_data(command_h: int, command_l: int, send_data: bytes= None) -> Optional[bytes]:                   
+        buffer = bytearray()
+        HEADER = bytes.fromhex('86 AB')  # 帧头
+        FOOTER = bytes.fromhex('CF')     # 帧尾
+        MIN_FRAME_LEN = 9                # 最小帧长度           
+        if send_data:            
+            pro_check = base_driver.calculate_pro_check(command_h, command_l, list(send_data))
+            send_packet = [0x86, 0xAB, (0x09+len(send_data))//256, (0x09+len(send_data))%256, command_h, command_l, *send_data, 0x01, pro_check, 0xCF]
+        else:
+            pro_check = base_driver.calculate_pro_check(command_h, command_l)
+            send_packet = [0x86, 0xAB, 0x00, 0x09, command_h, command_l, 0x01, pro_check, 0xCF]
+        send_bytes = bytes(send_packet)
+        
+        ser.write(send_bytes)
+                     
+            
+    def check_frame(frame: bytes) -> bool:
+        # 简化版校验，实际应根据协议实现
+        if len(frame) < 9:
+            return False
+            
+        # 计算校验和
+        calculated_checksum = (sum(frame[:-2])+frame[-1])%256
+        frame_checksum = frame[-2]  # 倒数第二个字节是校验和
+        
+        return calculated_checksum == frame_checksum
+    
+    def process_received_data():
+        global buffer
+        # 读取所有可用数据
+        data = ser.read(ser.in_waiting or 1)
+        if data:
+            buffer.extend(data)
+        while len(buffer)>=2:
+#            for x in buffer:
+#                print(f"{x:02X}", end=' ')
+#            print("\n")
+            # 1. 查找帧头
+            start_idx = buffer.find(HEADER)
+            if start_idx == -1:
+                # 没有找到帧头，清空无效数据（保留最后可能的部分帧头）
+                #print("Header no found")
+                if len(buffer) > len(HEADER) - 1:
+                    buffer = buffer[-len(HEADER) + 1:]
+                return                 
+            # 2. 检查帧头后的长度字段是否足够
+            if start_idx + 4 > len(buffer):
+                # 长度字段不完整，等待更多数据
+                return                
+            # 3. 解析帧长度
+            frame_length = (buffer[start_idx + 2] << 8) + buffer[start_idx + 3]          
+            # 4. 检查完整帧是否已到达
+            end_idx = start_idx + frame_length - 1
+            if end_idx >= len(buffer):
+                # 完整帧尚未完全到达
+                return                
+            # 5. 检查帧尾
+            if buffer[end_idx] != ord(FOOTER):
+                # 跳过当前帧头，继续查找
+                print("End no found")
+                buffer = buffer[start_idx + 1:]
+                continue               
+            # 6. 提取完整帧
+            frame = buffer[start_idx:end_idx + 1]
+            frames_queue.append(frame)            
+            # 7. 从缓冲区移除已处理帧
+            buffer = buffer[end_idx + 1:]        
+        # 处理所有完整帧
+        if len(frames_queue) > 0:
+            frame = frames_queue.popleft()
+            if base_driver.check_frame(frame):
+                return frame
+            else:
+                print("Check byte error")
+                
+# 功能函数类
+class Uart3_funtions:
+
+##############################################################################读取设备信息
+    """固件升级模式"""
+    def boot_update() -> None:
+        base_driver.write_data(BOOT_UPDATE_H, BOOT_UPDATE_L)       
+        while True:
+            response =base_driver.process_received_data()
+            if response:
+                display_data = response[6:-3]
+                if display_data[0]==0X03:
+                    print("固件更新启动\n")
+                elif display_data[0]==0X01:
+                    print("擦除中......",f"{10*display_data[1]}","%\n")
+                elif display_data[0]==0X02:
+                    print("升级中......",f"{10*display_data[1]}","%\n")              
+                elif display_data[0]==0X05:
+                    print("更新成功！\n")
+                elif display_data[0]==0X06:
+                    print("更新失败！\n")
+                else:
+                    for x in display_data:
+                        print(f"{x:02X}", end=' ')
+                    print("\n")
+                
+
+    """读取设备型号"""
+    def read_device_model() -> Optional[bytes]:
+        base_driver.write_data(READ_MODEL_H, READ_MODEL_L)
+        start_time = time.time()
+        while True:
+            response =base_driver.process_received_data()
+            if response:
+                display_data = response[6:-3].decode(errors="ignore")
+                print(f"设备型号: {display_data}")
+                return display_data
+            else:
+                if time.time() - start_time > 3:
+                    print("读取超时")
+                    buffer.clear() 
+                    return -1
+
+    """读取版本号"""
+    def read_version() -> Optional[bytes]:
+        base_driver.write_data(READ_VERSION_H, READ_VERSION_L)
+        start_time = time.time()
+        while True:
+            response =base_driver.process_received_data()
+            if response:
+                display_data = response[6:-3].decode(errors="ignore")
+                print(f"版本号: {display_data}")
+                return display_data
+            else:
+                if time.time() - start_time > 3:
+                    print("读取超时")
+                    buffer.clear() 
+                    return -1
+
+    """读取工厂信息"""
+    def read_factory_data() -> Optional[bytes]:
+        base_driver.write_data(READ_FACTORY_H, READ_FACTORY_L)
+        start_time = time.time()
+        while True:
+            response =base_driver.process_received_data()
+            if response:
+                display_data = response[6:-3].decode(errors="ignore")
+                print(f"厂家信息: {display_data}")
+                return display_data
+            else:
+                if time.time() - start_time > 3:
+                    print("读取超时")
+                    buffer.clear() 
+                    return -1
+
+    """读取硬件ID"""
+    def read_hardware_ID() -> Optional[bytes]:
+        base_driver.write_data(READ_HW_ID_H, READ_HW_ID_L)
+        start_time = time.time()
+        while True:
+            response =base_driver.process_received_data()
+            if response:
+                display_data = response[6:-3].decode(errors="ignore")
+                print(f"硬件ID: {display_data}")
+                return display_data
+            else:
+                if time.time() - start_time > 3:
+                    print("读取超时")
+                    buffer.clear() 
+                    return -1
+            
+    """读取设备名称"""
+    def read_device_name() -> Optional[bytes]:        
+        base_driver.write_data(READ_NAME_H, READ_NAME_L)
+        start_time = time.time()
+        while True:
+            response =base_driver.process_received_data()
+            if response:
+                display_data = response[6:-3].decode(errors="ignore")
+                print(f"设备名称: {display_data}")
+                return display_data
+            else:
+                if time.time() - start_time > 3:
+                    print("读取超时")
+                    buffer.clear() 
+                    return -1
+            
+    """设置设备名称"""
+    def write_device_name(send_data: str) -> Optional[bytes]:
+        data_bytes = send_data.encode('utf-8')
+        base_driver.write_data(WRITE_NAME_H, WRITE_NAME_L, data_bytes)
+        start_time = time.time()
+        while True:
+            response =base_driver.process_received_data()
+            if response:
+                display_data = response[6:-3].decode(errors="ignore")
+                print(f"设置状态: {display_data}")
+                return display_data
+            else:
+                if time.time() - start_time > 3:
+                    print("读取超时")
+                    buffer.clear() 
+                    return -1
+            
+    """读取连接方式"""#长度位少了1
+    def read_connected() -> Optional[bytes]: 
+        base_driver.write_data(READ_CONNECT_H, READ_CONNECT_L)
+        start_time = time.time()
+        while True:
+            response =base_driver.process_received_data()
+            if response:
+                display_data = response[6:-3].decode(errors="ignore")
+                print(f"连接方式: {display_data}")
+                return display_data
+            else:
+                if time.time() - start_time > 3:
+                    print("读取超时")
+                    buffer.clear() 
+                    return -1
+        
+    """读取电池电量"""        
+    def read_battery() -> Optional[bytes]: 
+        base_driver.write_data(READ_BAT_H, READ_BAT_L)
+        start_time = time.time()
+        while True:
+            response =base_driver.process_received_data()
+            if response:
+                display_data = response[6:-3]
+#                for x in display_data:
+#                    print(f"{x:02X}", end=' ')
+                print(f"电池电量: {display_data}")
+                return display_data
+            else:
+                if time.time() - start_time > 3:
+                    print("读取超时")
+                    buffer.clear() 
+                    return -1
+            
+###############################################################################固件升级
+    
+    """下载更新请求"""
+    def update_request() -> Optional[bytes]:
+        base_driver.write_data(UPDATE_REQUEST_H, UPDATE_REQUEST_L)
+        start_time = time.time()
+        while True:
+            response =base_driver.process_received_data()
+            if response:
+                display_data = response[6:-3].decode(errors="ignore")
+                print(f"从机响应: {display_data}")
+                return display_data
+            else:
+                if time.time() - start_time > 3:
+                    print("读取超时")
+                    buffer.clear() 
+                    return -1
+
+    """查询最大通讯长度"""
+    def read_max_com_len() -> Optional[bytes]:
+        base_driver.write_data(MAX_COM_LEN_H, MAX_COM_LEN_L)
+        start_time = time.time()
+        while True:
+            response =base_driver.process_received_data()
+            if response:
+                display_data = response[6:-3].decode(errors="ignore")
+                print(f"从机响应: {display_data}")
+                return display_data
+            else:
+                if time.time() - start_time > 3:
+                    print("读取超时")
+                    buffer.clear() 
+                    return -1
+
+    """下载文件的信息"""
+    def download_massage() -> Optional[bytes]:
+        base_driver.write_data(DL_MESSAGE_H, DL_MESSAGE_L, file_data)#文件信息来源从哪获取？
+        start_time = time.time()
+        while True:
+            response =base_driver.process_received_data()
+            if response:
+                display_data = response[6:-3].decode(errors="ignore")
+                print(f"从机响应: {display_data}")
+                return display_data
+            else:
+                if time.time() - start_time > 3:
+                    print("读取超时")
+                    buffer.clear() 
+                    return -1
+
+    """查询设备状态"""
+    def read_device_status() -> Optional[bytes]:
+        base_driver.write_data(READ_STATUS_H, READ_STATUS_L)
+        start_time = time.time()
+        while True:
+            response =base_driver.process_received_data()
+            if response:
+                display_data = response[6:-3].decode(errors="ignore")
+                print(f"从机响应: {display_data}")
+                return display_data
+            else:
+                if time.time() - start_time > 3:
+                    print("读取超时")
+                    buffer.clear() 
+                    return -1
+            
+    """发送页校验码"""
+    def write_page_check() -> Optional[bytes]:
+        base_driver.write_data(PAGE_CHECK_H, PAGE_CHECK_L, page_check_data)
+        start_time = time.time()
+        while True:
+            response =base_driver.process_received_data()
+            if response:
+                display_data = response[6:-3].decode(errors="ignore")
+                print(f"从机响应: {display_data}")
+                return display_data
+            else:
+                if time.time() - start_time > 3:
+                    print("读取超时")
+                    buffer.clear() 
+                    return -1          
+            
+    """发送页数据"""
+    def write_page_check() -> Optional[bytes]:
+        base_driver.write_data(PAGE_SEND_H, PAGE_SEND_L, page_send_data)
+        start_time = time.time()
+        while True:
+            response =base_driver.process_received_data()
+            if response:
+                display_data = response[6:-3].decode(errors="ignore")
+                print(f"从机响应: {display_data}")
+                return display_data
+            else:
+                if time.time() - start_time > 3:
+                    print("读取超时")
+                    buffer.clear() 
+                    return -1
+         
+###############################################################################读取传感器信息
+
+    """读取外设连接情况"""
+    def read_peripheral() -> Optional[bytes]:   
+        base_driver.write_data(READ_PERIPH_H, READ_PERIPH_L)
+        start_time = time.time()
+        while True:
+            response =base_driver.process_received_data()
+            if response:
+                display_data = response[6:-3]
+                for x in display_data:
+                    print(f"{x:02X}", end=' ')
+                print("\n")
+                return display_data
+            else:
+                if time.time() - start_time > 3:
+                    print("读取超时")
+                    buffer.clear() 
+                    return -1 
+   
+    """单次操作外设"""         
+    def single_operate_sensor(op_struct: bytes) -> Optional[bytes]:       
+        base_driver.write_data(SINGLE_OP_H, SINGLE_OP_L, op_struct)
+        start_time = time.time()
+        while True:
+            response =base_driver.process_received_data()
+            if response:
+                display_data = response[6:-3]
+                for x in display_data:
+                    print(f"{x:02X}", end=' ')
+                print("\n")
+                return display_data
+            else:
+                if time.time() - start_time > 3:
+                    print("读取超时")
+                    buffer.clear() 
+                    return -1    
+                  
+    """从机模式转换"""         
+    def mode_change(send_data: str) -> Optional[bytes]:     
+        base_driver.write_data(MODE_CHANGE_H, MODE_CHANGE_L, send_data)
+        start_time = time.time()
+        while True:
+            response =base_driver.process_received_data()
+            if response:
+                display_data = response[6:-3]
+                for x in display_data:
+                    print(f"{x:02X}", end=' ')
+                print("\n")
+                return display_data
+            else:
+                if time.time() - start_time > 3:
+                    print("读取超时")
+                    buffer.clear() 
+                    return -1
+            
+    """智能模式发送周期"""         
+    def mode_change(send_data: str) -> Optional[bytes]:       
+        base_driver.write_data(SEND_CYCLE_H, SEND_CYCLE_L, send_data)
+        start_time = time.time()
+        while True:
+            response =base_driver.process_received_data()
+            if response:
+                display_data = response[6:-3]
+                for x in display_data:
+                    print(f"{x:02X}", end=' ')
+                print("\n")
+                return display_data
+            else:
+                if time.time() - start_time > 3:
+                    print("读取超时")
+                    buffer.clear() 
+                    return -1
+
+            
+         
+            

smartpi/mpu6500.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+import time
+import math
+from smbus import SMBus
+
+MPU_ADDR = 0x68          # 根据AD0引脚调整
+I2C_BUS = 3              # I2C-3接口
+ACCEL_RANGE = 0x00       # ±2g
+GYRO_RANGE = 0x18        # ±2000°/s
+SAMPLING_RATE = 100      # 100Hz
+
+# DMP固件数据（示例数据，需根据传感器型号调整）
+DMP_FIRMWARE = [
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    # 此处省略实际固件数据（需从官方获取）
+]
+
+class MPU6500:
+    def __init__(self):
+        self.bus = SMBus(I2C_BUS)
+        self.registers = {
+            'PWR_MGMT_1': 0x6B,
+            'GYRO_CFG': 0x1B,
+            'ACCEL_CFG': 0x1C,
+            'SMPLRT_DIV': 0x19,
+            'USER_CTRL': 0x6A,
+            'FIFO_EN': 0x23,
+            'FIFO_COUNT_H': 0x72,
+            'FIFO_R_W': 0x74,
+            'DMP_CFG_1': 0x70,
+            'DMP_CFG_2': 0x71,
+            'WHO_AM_I': 0x75
+        }
+        
+        self.gyro_scale = self._get_gyro_scale(GYRO_RANGE)
+        self.accel_scale = self._get_accel_scale(ACCEL_RANGE)
+        self._initialize_hardware()
+#        self._load_dmp_firmware()
+        self._configure_dmp()
+    
+    def _initialize_hardware(self):
+        """初始化硬件寄存器"""
+        self._write_reg('PWR_MGMT_1', 0x80)  # 软复位
+        time.sleep(0.1)
+        self._write_reg('PWR_MGMT_1', 0x01)  # 唤醒，选择陀螺仪X轴时钟
+        time.sleep(0.1)
+        
+        self._write_reg('GYRO_CFG', GYRO_RANGE)
+        self._write_reg('ACCEL_CFG', ACCEL_RANGE)
+        self._write_reg('SMPLRT_DIV', (1000 // SAMPLING_RATE) - 1)
+    
+    def _load_dmp_firmware(self):
+        """加载DMP固件（示例，需替换为实际固件）"""
+        print("加载DMP固件...")
+        for addr, data in enumerate(DMP_FIRMWARE):
+            self._write_reg(0x40 + addr, data)  # 固件从0x40地址开始写入
+            time.sleep(0.001)
+        print("固件加载完成")
+    
+    def _configure_dmp(self):
+        """配置DMP参数"""
+        self._write_reg('USER_CTRL', 0x00)  # 禁用DMP
+        self._write_reg('FIFO_EN', 0x00)    # 禁用FIFO
+        self._write_reg('DMP_CFG_1', 0x03)  # 设置DMP采样率
+        self._write_reg('DMP_CFG_2', 0x00)  # 禁用低功耗模式
+        
+        self._write_reg('USER_CTRL', 0x10)  # 复位FIFO
+        time.sleep(0.01)
+        self._write_reg('USER_CTRL', 0x80)  # 启用DMP
+        time.sleep(0.1)
+        self._write_reg('FIFO_EN', 0x40)    # 启用四元数FIFO
+    
+    def _write_reg(self, reg, value):
+        """安全写入寄存器（支持寄存器名称字符串或数值地址）"""
+        if isinstance(reg, str):
+            reg_addr = self.registers[reg]
+        else:
+            reg_addr = reg
+            
+        try:
+            self.bus.write_byte_data(MPU_ADDR, reg_addr, value)
+        except Exception as e:
+            print(f"写入寄存器0x{reg_addr:02X}失败: {e}")
+    
+    def read_dmp_quaternion(self):
+        """读取DMP生成的四元数"""
+        high = self.bus.read_byte_data(MPU_ADDR, self.registers['FIFO_COUNT_H'])
+        low = self.bus.read_byte_data(MPU_ADDR, self.registers['FIFO_COUNT_H'] + 1)
+        fifo_len = (high << 8) | low
+        
+        if fifo_len < 8:
+            return None
+        
+        data = self.bus.read_i2c_block_data(MPU_ADDR, self.registers['FIFO_R_W'], 8)
+        return self._parse_quaternion(data)
+    
+    def _parse_quaternion(self, bytes):
+        """解析四元数（小端模式）"""
+        q1 = self._bytes_to_sint16(bytes[0:2]) / 32768.0
+        q2 = self._bytes_to_sint16(bytes[2:4]) / 32768.0
+        q3 = self._bytes_to_sint16(bytes[4:6]) / 32768.0
+        q4 = self._bytes_to_sint16(bytes[6:8]) / 32768.0
+        return (q1, q2, q3, q4)
+    
+    def _bytes_to_sint16(self, bytes):
+        val = (bytes[1] << 8) | bytes[0]
+        return val if val < 32768 else val - 65536
+    
+    def _get_gyro_scale(self, range_bits):
+        return {0x18: 16.4}[range_bits]
+    
+    def _get_accel_scale(self, range_bits):
+        return {0x00: 16384.0}[range_bits]
+
+if __name__ == "__main__":
+    mpu = MPU6500()
+    print("开始读取DMP数据...")
+    
+    try:
+        while True:
+            q = mpu.read_dmp_quaternion()
+            if q:
+                norm = math.sqrt(sum(x**2 for x in q))
+                if norm > 0.5:  # 仅输出有效四元数
+                    print(f"四元数: {q}, 模长: {norm}")
+                else:
+                    print("警告：四元数无效，模长过低")
+            time.sleep(0.1)
+    except KeyboardInterrupt:
+        print("程序停止")

smartpi-0.1.0.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.1
+Name: smartpi
+Version: 0.1.0
+Summary: A library use for H2-RCU
+Author-email: Driver_cai <1547363120@qq.com>
+Project-URL: Homepage, https://github.com/Drvier_cai/smartpi
+Project-URL: Bug Tracker, https://github.com/Driver/smartpi/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+

smartpi-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+smartpi/__init__.py,sha256=_xzkH8V5GZzuj5JxMhfOT0D3mnDrxPJeshfHYyOxSqU,55
+smartpi/app_module.py,sha256=g0YoZV1EKj4U3KIcqF5Gs3xhxPo8hHnZxKns7vmv3OY,4377
+smartpi/module.py,sha256=499JtkF4Rb_syg9xlSjGWbSWw4-2JovOhLg8GJawCKw,19318
+smartpi/mpu6500.py,sha256=UzlRg-n228ZKWO08nh1Mmmk3Y2JJR59fPWABciF7Fck,4723
+smartpi-0.1.0.dist-info/METADATA,sha256=pUCer6guyr5lSW6uonMAOA327Z-yNood_XdsTl0pBBA,468
+smartpi-0.1.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+smartpi-0.1.0.dist-info/top_level.txt,sha256=PoLhUCmWAiQUg5UeN2fS-Y1iQyBbF2rdUlizXtpHGRQ,8
+smartpi-0.1.0.dist-info/RECORD,,

smartpi-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

smartpi-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+smartpi