smartpi 0.1.38__py3-none-any.whl

smartpi/camera.py

@@ -0,0 +1,84 @@
+# coding: utf-8
+import cv2
+import os
+import time
+import platform
+
+class Camera:
+    def __init__(self, indexes=[0, 1, 2, 3], target_width=640, target_height=480):
+        self.cap = None
+        self.indexes = indexes
+        self.target_width = target_width
+        self.target_height = target_height
+        self.open_camera()
+    
+    def open_camera(self):
+        """打开摄像头（硬件加速+参数优化）"""
+        for idx in self.indexes:
+            try:
+                # 适配linux/Android的V4L2硬件加速（RK芯片优先）
+                if platform.system() == "Linux":
+                    cap = cv2.VideoCapture(idx, cv2.CAP_V4L2)
+                    # 尝试启用硬件加速（兼容不同OpenCV版本）
+                    try:
+                        # 对于较新版本的OpenCV
+                        if hasattr(cv2, 'CAP_PROP_HW_ACCELERATION') and hasattr(cv2, 'VIDEO_ACCELERATION_ANY'):
+                            cap.set(cv2.CAP_PROP_HW_ACCELERATION, cv2.VIDEO_ACCELERATION_ANY)
+                    except AttributeError as ae:
+                        print(f"硬件加速设置不支持，使用默认配置: {ae}")
+                else:
+                    cap = cv2.VideoCapture(idx)
+                
+                if cap.isOpened():
+                    # 尝试设置分辨率
+                    cap.set(cv2.CAP_PROP_FRAME_WIDTH, self.target_width)
+                    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, self.target_height)
+                    
+                    # 获取实际设置的分辨率
+                    actual_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+                    actual_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+                    
+                    print(f"摄像头 {idx} 已打开, 分辨率: {actual_width}x{actual_height}")
+                    self.cap = cap
+                    return True
+            except Exception as e:
+                print(f"尝试打开摄像头 {idx} 失败: {e}")
+                continue
+        
+        print("无法打开任何摄像头")
+        return False
+    
+    def read_frame(self):
+        """读取一帧并自动处理错误"""
+        if not self.cap or not self.cap.isOpened():
+            return False, None
+            
+        ret, frame = self.cap.read()
+        if not ret:
+            print("读取帧失败，尝试重新打开摄像头...")
+            self.release()
+            time.sleep(1)
+            if self.open_camera():
+                return self.read_frame()
+            return False, None
+        
+        # 调整到目标分辨率
+        if frame.shape[1] != self.target_width or frame.shape[0] != self.target_height:
+            frame = cv2.resize(frame, (self.target_width, self.target_height))
+            
+        return True, frame
+    
+    def get_resolution(self):
+        """获取当前分辨率"""
+        if self.cap and self.cap.isOpened():
+            return (
+                int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH)),
+                int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+            )
+        return self.target_width, self.target_height
+    
+    def release(self):
+        """释放摄像头资源"""
+        if self.cap and self.cap.isOpened():
+            self.cap.release()
+            self.cap = None

smartpi/color_sensor.py

@@ -0,0 +1,18 @@
+# coding=utf-8
+import time
+from typing import List, Optional
+from smartpi import base_driver
+
+#��ɫ��ȡ  ��������ֵ��1-��ɫ��2-��ɫ��3-��ɫ��4-��ɫ��5-��ɫ��6-��ɫ��  ��ȡ����-1  
+def get_value(port:bytes) -> Optional[bytes]:
+    color_str=[0xA0, 0x04, 0x00, 0xBE]
+    color_str[0]=0XA0+port
+    color_str[2]=1
+    time.sleep(0.005)
+    response = base_driver.single_operate_sensor(color_str,0)        
+    if response == None:
+        return None
+    else:
+        return response[4]
+        
+        

smartpi/cw2015.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+import os
+import sys
+import fcntl
+import time
+
+# I2C设备文件路径
+I2C_DEV_PATH = "/dev/i2c-2"  # 根据实际情况修改总线号
+
+# I2C从设备地址
+CW2015_ADDR = 0x62  # 7位地址
+
+# I2C通信常量
+I2C_SLAVE = 0x0703
+I2C_SMBUS = 0x0720  # SMBus传输
+
+# SMBus命令结构
+class i2c_smbus_ioctl_data:
+    def __init__(self, read_write, command, size, data):
+        self.read_write = read_write  # 0 = write, 1 = read
+        self.command = command        # 寄存器地址
+        self.size = size              # 数据大小
+        self.data = data              # 数据指针
+
+# 寄存器地址定义
+VERSION = 0x00
+VCELL_H = 0x02
+VCELL_L = 0x03
+SOC_B = 0x04
+SOC = 0x05
+RRT_H = 0x06
+RRT_L = 0x07
+CONFIG = 0x08
+MOOD = 0x0A
+
+class I2CDevice:
+    """通过设备文件直接访问I2C设备"""
+    def __init__(self, device_path, device_addr):
+        """
+        初始化I2C设备
+        :param device_path: I2C设备文件路径 (例如 "/dev/i2c-2")
+        :param device_addr: I2C从设备地址 (7位地址)
+        """
+        self.device_path = device_path
+        self.device_addr = device_addr
+        self.fd = None
+        
+        try:
+            # 打开设备文件
+            self.fd = os.open(device_path, os.O_RDWR)
+            # 设置从设备地址
+            fcntl.ioctl(self.fd, I2C_SLAVE, device_addr)
+            #print(f"成功打开 {device_path} 并设置地址 0x{device_addr:02X}")
+        except Exception as e:
+            print(f"打开I2C设备失败: {e}")
+            if self.fd:
+                os.close(self.fd)
+            sys.exit(1)
+    
+    def __del__(self):
+        """关闭设备文件"""
+        if self.fd:
+            os.close(self.fd)
+    
+    def write_byte(self, reg_addr, value):
+        """
+        向寄存器写入一个字节
+        :param reg_addr: 寄存器地址
+        :param value: 要写入的值
+        :return: 成功返回True，失败返回False
+        """
+        try:
+            # 构造写入数据：寄存器地址 + 值
+            data = bytes([reg_addr, value])
+            os.write(self.fd, data)
+            return True
+        except Exception as e:
+            print(f"写入寄存器0x{reg_addr:02X}失败: {e}")
+            return False
+    
+    def read_byte(self, reg_addr):
+        """
+        从寄存器读取一个字节
+        :param reg_addr: 寄存器地址
+        :return: 读取到的字节值，失败返回0
+        """
+        try:
+            # 先写入寄存器地址
+            os.write(self.fd, bytes([reg_addr]))
+            # 然后读取一个字节
+            value = os.read(self.fd, 1)
+            return value[0] if value else 0
+        except Exception as e:
+            print(f"读取寄存器0x{reg_addr:02X}失败: {e}")
+            return 0
+    
+    def read_word(self, reg_addr):
+        """
+        从寄存器读取两个字节（先高字节后低字节）
+        :param reg_addr: 寄存器地址（高字节寄存器）
+        :return: (高字节 << 8) | 低字节
+        """
+        try:
+            # 先写入寄存器地址
+            os.write(self.fd, bytes([reg_addr]))
+            # 读取两个字节
+            data = os.read(self.fd, 2)
+            if len(data) == 2:
+                return (data[0] << 8) | data[1]
+            else:
+                return 0
+        except Exception as e:
+            print(f"读取寄存器0x{reg_addr:02X}失败: {e}")
+            return 0
+
+class CW2015:
+    """CW2015电池监测芯片驱动"""
+    def __init__(self, i2c_dev_path=I2C_DEV_PATH, i2c_addr=CW2015_ADDR):
+        """
+        初始化CW2015
+        :param i2c_dev_path: I2C设备路径
+        :param i2c_addr: I2C地址
+        """
+        self.device = I2CDevice(i2c_dev_path, i2c_addr)
+    
+    def init(self):
+        """初始化芯片配置"""
+        # 写入配置
+        if not self.device.write_byte(CONFIG, 0x50):
+            print("配置寄存器写入失败")
+            return False
+        if not self.device.write_byte(MOOD, 0x00):
+            print("模式寄存器写入失败")
+            return False
+        
+        time.sleep(0.05)  # 50ms延时
+        #print("CW2015初始化完成")
+        return True
+    
+    def get_id(self):
+        """获取芯片ID"""
+        return self.device.read_byte(VERSION)
+    
+    def get_voltage(self):
+        """读取电池电压(mV)"""
+        # 读取电压高字节寄存器
+        vh = self.device.read_byte(VCELL_H)
+        # 读取电压低字节寄存器
+        vl = self.device.read_byte(VCELL_L)
+        
+        # 组合14位ADC值
+        adc_value = ((vh & 0x3F) << 8) | vl
+        # 转换为电压值 (305μV/LSB)
+        voltage = adc_value * 305 / 1000
+        return int(voltage)
+    
+    def get_soc(self, mode=0):
+        """读取电池剩余电量"""
+        if mode == 0:
+            return self.device.read_byte(SOC_B)  # 百分比整数
+        else:
+            return self.device.read_byte(SOC)     # 高精度值
+    
+    def get_remaining_time(self):
+        """获取剩余工作时间(分钟)"""
+        # 读取时间高字节寄存器
+        rh = self.device.read_byte(RRT_H)
+        # 读取时间低字节寄存器
+        rl = self.device.read_byte(RRT_L)
+        
+        # 提取剩余时间（13位）
+        remaining_time = ((rh & 0x1F) << 8) | rl
+        return remaining_time
+    
+    def get_alert_status(self):
+        """获取告警状态"""
+        rh = self.device.read_byte(RRT_H)
+        return (rh >> 7) & 0x01
+

smartpi/flash.py

@@ -0,0 +1,130 @@
+import os
+import struct
+import fcntl
+
+# 配置文件路径 (当前目录下的flash.bin)
+FLASH_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "/home/Interface/flash/flash.bin")
+FLASH_FILE_2 = os.path.join(os.path.dirname(os.path.abspath(__file__)), "/home/Interface/flash/flash_2.bin")
+
+DATA_SIZE = 2  # 每个数据2字节
+TOTAL_SLOTS = 120  # 100个数据槽
+
+def _init_flash_file():
+    """初始化存储文件"""
+    if not os.path.exists(FLASH_FILE):
+        with open(FLASH_FILE, "wb") as f:
+            f.write(b'\x00' * DATA_SIZE * TOTAL_SLOTS)
+
+def write(address, data):
+    """
+    写入数据到指定地址
+    :param address: 地址编号 (1-100)
+    :param data: 要写入的整数数据 (2字节范围)
+    """
+    if not 1 <= address <= TOTAL_SLOTS:
+        raise ValueError(f"地址必须在1-{TOTAL_SLOTS}范围内")
+    
+    # 2字节数据范围: 0-65535 (0xFFFF)
+    if not 0 <= data <= 0xFFFF:
+        raise ValueError("数据必须在0-65535范围内")
+    
+    _init_flash_file()
+    
+    # 计算文件偏移量 (每个地址2字节)
+    offset = (address - 1) * DATA_SIZE
+    
+    with open(FLASH_FILE, "r+b") as f:
+        # 使用文件锁确保写入安全
+        fcntl.flock(f, fcntl.LOCK_EX)
+        f.seek(offset)
+        # 将整数打包为2字节小端格式
+        f.write(struct.pack('<H', data))
+        f.flush()
+        fcntl.flock(f, fcntl.LOCK_UN)
+
+def read(address):
+    """
+    从指定地址读取数据
+    :param address: 地址编号 (1-100)
+    :return: 读取到的整数数据
+    """
+    if not 1 <= address <= TOTAL_SLOTS:
+        raise ValueError(f"地址必须在1-{TOTAL_SLOTS}范围内")
+    
+    _init_flash_file()
+    
+    offset = (address - 1) * DATA_SIZE
+    
+    with open(FLASH_FILE, "rb") as f:
+        fcntl.flock(f, fcntl.LOCK_SH)  # 共享锁
+        f.seek(offset)
+        # 读取2字节并解包为整数
+        data_bytes = f.read(DATA_SIZE)
+        fcntl.flock(f, fcntl.LOCK_UN)
+        
+        if len(data_bytes) != DATA_SIZE:
+            return 0  # 返回默认值0
+            
+        return struct.unpack('<H', data_bytes)[0]
+
+# 可选扩展功能
+def erase_all():
+    """擦除所有数据(重置为0)"""
+    with open(FLASH_FILE, "wb") as f:
+        f.write(b'\x00' * DATA_SIZE * TOTAL_SLOTS)
+        
+            
+def _init_flash_file_2():
+    """初始化存储文件"""
+    if not os.path.exists(FLASH_FILE_2):
+        with open(FLASH_FILE_2, "wb") as f:
+            f.write(b'\x00' * DATA_SIZE * TOTAL_SLOTS)
+        
+def write_2(address, data):
+    if not 1 <= address <= TOTAL_SLOTS:
+        raise ValueError(f"地址必须在1-{TOTAL_SLOTS}范围内")
+    
+    # 2字节数据范围: 0-65535 (0xFFFF)
+    if not 0 <= data <= 0xFFFF:
+        raise ValueError("数据必须在0-65535范围内")
+    
+    _init_flash_file_2()
+    
+    # 计算文件偏移量 (每个地址2字节)
+    offset = (address - 1) * DATA_SIZE
+    
+    with open(FLASH_FILE_2, "r+b") as f:
+        # 使用文件锁确保写入安全
+        fcntl.flock(f, fcntl.LOCK_EX)
+        f.seek(offset)
+        # 将整数打包为2字节小端格式
+        f.write(struct.pack('<H', data))
+        f.flush()
+        fcntl.flock(f, fcntl.LOCK_UN)
+
+def read_2(address):
+    if not 1 <= address <= TOTAL_SLOTS:
+        raise ValueError(f"地址必须在1-{TOTAL_SLOTS}范围内")
+    
+    _init_flash_file_2()
+    
+    offset = (address - 1) * DATA_SIZE
+    
+    with open(FLASH_FILE_2, "rb") as f:
+        fcntl.flock(f, fcntl.LOCK_SH)  # 共享锁
+        f.seek(offset)
+        # 读取2字节并解包为整数
+        data_bytes = f.read(DATA_SIZE)
+        fcntl.flock(f, fcntl.LOCK_UN)
+        
+        if len(data_bytes) != DATA_SIZE:
+            return 0  # 返回默认值0
+            
+        return struct.unpack('<H', data_bytes)[0]
+
+# 可选扩展功能
+def erase_all_2():
+    """擦除所有数据(重置为0)"""
+    with open(FLASH_FILE_2, "wb") as f:
+        f.write(b'\x00' * DATA_SIZE * TOTAL_SLOTS)
+        

smartpi/humidity.py

@@ -0,0 +1,20 @@
+# coding=utf-8
+import time
+from typing import List, Optional
+from smartpi import base_driver
+
+             
+#湿度读取 port:连接P端口；正常返回：湿度数据; 读取错误：-1
+def get_value(port:bytes) -> Optional[bytes]:
+    humi_str=[0XA0, 0X0C, 0X01, 0X71, 0X00, 0XBE]
+    humi_str[0]=0XA0+port
+    humi_str[4]=0X01 
+    time.sleep(0.005)
+    response = base_driver.single_operate_sensor(humi_str,0)
+    if response == None:
+        return None
+    else:
+        return response[4]
+
+
+

smartpi/led.py

@@ -0,0 +1,19 @@
+# coding=utf-8
+import time
+from typing import List, Optional
+from smartpi import base_driver
+
+
+#�ʵƿ��� port:����P�˿ڣ�command:0:�صƣ�1:�죻2:�̣�3:����4:�ƣ�5:�ϣ�6:�ࣻ7:�ף�  �������أ�0; ��ȡ����-1  
+def set_color(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 = base_driver.single_operate_sensor(color_lamp_str,0)
+    time.sleep(0.005)
+    base_driver.write_data(0X01, 0X02, color_lamp_str)
+#    if response == None:
+#        return None
+#    else:
+    return 0
+        

smartpi/light_sensor.py

@@ -0,0 +1,72 @@
+# coding=utf-8
+import time
+from typing import List, Optional
+from smartpi import base_driver
+
+#����ֵ��ȡ port:����P�˿ڣ�  �������أ���ֵ����; ��ȡ����-1  
+def turn_off(port:bytes) -> Optional[bytes]:
+    light_str=[0xA0, 0x02, 0x00, 0xBE]
+    light_str[0]=0XA0+port
+    light_str[2]=0x03
+#    response = base_driver.single_operate_sensor(light_str,0) 
+    base_driver.write_data(0X01, 0X02, light_str)     
+#    if response == None:
+#        return None
+#    else:
+    return 0
+
+#����ֵ��ȡ port:����P�˿ڣ�  �������أ���ֵ����; ��ȡ����-1  
+def get_value(port:bytes) -> Optional[bytes]:
+    light_str=[0xA0, 0x02, 0x00, 0xBE]
+    light_str[0]=0XA0+port
+    light_str[2]=0x01
+    time.sleep(0.005)
+    response = base_driver.single_operate_sensor(light_str,0)       
+    if response == None:
+        return None
+    else:
+        light_data=response[4:-1]
+        light_num=int.from_bytes(light_data, byteorder='big', signed=True)
+        return light_num
+        
+#�����ֵ���� port:����P�˿ڣ� threshold�����õ���ֵ0~4000
+def set_threshold(port:bytes,threshold:int) -> Optional[bytes]:
+    light_str=[0xA0, 0x02, 0x00, 0x81, 0x00, 0x00, 0xBE]
+    light_str[0]=0XA0+port
+    light_str[2]=0x04
+    light_str[4]=threshold//256
+    light_str[5]=threshold%256
+    time.sleep(0.005)
+    base_driver.write_data(0X01, 0X02, light_str)
+#    response = base_driver.single_operate_sensor(light_str,0)       
+#    if response == None:
+#        return None
+#    else:
+    return 0
+        
+#�����ֵ��ȡ port:����P�˿ڣ�  
+def get_threshold(port:bytes) -> Optional[bytes]:
+    light_str=[0xA0, 0x02, 0x00, 0xBE]
+    light_str[0]=0XA0+port
+    light_str[2]=0x05
+    time.sleep(0.005)
+    response = base_driver.single_operate_sensor(light_str,0)       
+    if response == None:
+        return None
+    else:
+        light_data=response[4:-1]
+        light_num=int.from_bytes(light_data, byteorder='big', signed=True)
+        return light_num
+        
+#����ȡ��ǰֵ���趨��ֵ�ȽϺ��boolֵ port:����P�˿ڣ�  
+def get_bool_data(port:bytes) -> Optional[bytes]:
+    light_str=[0xA0, 0x02, 0x00, 0xBE]
+    light_str[0]=0XA0+port
+    light_str[2]=0x06
+    time.sleep(0.005)
+    response = base_driver.single_operate_sensor(light_str,0)       
+    if response == None:
+        return None
+    else:
+        return response[4]
+        

smartpi/motor.py

@@ -0,0 +1,177 @@
+# coding=utf-8
+import time
+import struct
+from typing import List, Optional
+from smartpi import base_driver
+
+        
+#��������ȡ port:����M�˿ڣ�
+def get_motor_encoder(port:bytes) -> Optional[bytes]:
+    motor_str=[0xA0, 0x01, 0x01, 0xBE]           
+    motor_str[0]=0XA0+port  
+    time.sleep(0.005)     
+    response = base_driver.single_operate_sensor(motor_str,0)        
+    if response == None:
+        return None
+    else:
+        code_data=response[4:-1]
+        code_num=int.from_bytes(code_data, byteorder='big', signed=True)
+        return code_num
+        
+#����������� port:����M�˿ڣ�
+def reset_motor_encoder(port:bytes) -> Optional[bytes]:
+    motor_str=[0xA0, 0x01, 0x03, 0xBE]           
+    motor_str[0]=0XA0+port       
+#    response = base_driver.single_operate_sensor(motor_str,0)
+    time.sleep(0.005)
+    base_driver.write_data(0X01, 0X02, motor_str)
+#    if response == None:
+#        return None
+#    else:
+    return 0
+        
+#���﷽����� port:����M�˿ڣ�dir:0��1
+def set_motor_direction(port:bytes,direc:bytes) -> Optional[bytes]:
+    motor_str=[0xA0, 0x01, 0x06, 0x71, 0x00, 0xBE]           
+    motor_str[0]=0XA0+port
+    motor_str[4]=direc
+#    response = base_driver.single_operate_sensor(motor_str,0)
+    time.sleep(0.005)
+    base_driver.write_data(0X01, 0X02, motor_str)
+#    if response == None:
+#        return None
+#    else:
+    return 0
+        
+#�����ٶ�ת�� port:����M�˿ڣ�speed:-100~100
+def set_motor(port:bytes,speed:int) -> Optional[bytes]:
+    motor_str=[0xA0, 0x01, 0x02, 0x71, 0x00, 0xBE]           
+    motor_str[0]=0XA0+port
+    if speed>100:
+        m_par=100
+    elif speed>=0 and speed<=100:
+        m_par=speed        
+    elif speed<-100:
+        m_par=156
+    elif speed<=0 and speed>=-100:
+        m_par=256+speed
+        
+    motor_str[4]=m_par
+        
+#    response = base_driver.single_operate_sensor(motor_str,0)
+    time.sleep(0.005)
+    base_driver.write_data(0X01, 0X02, motor_str)
+#    if response == None:
+#        return None
+#    else:
+    return 0
+        
+#����ֹͣ port:����M�˿ڣ�
+def set_motor_stop(port:bytes) -> Optional[bytes]:
+    motor_str=[0xA0, 0x01, 0x0B, 0xBE]           
+    motor_str[0]=0XA0+port
+#    response = base_driver.single_operate_sensor(motor_str,0)
+    time.sleep(0.005)
+    base_driver.write_data(0X01, 0X02, motor_str)
+#    if response == None:
+#        return None
+#    else:
+    return 0
+        
+#����Ƕȿ��� port:����M�˿ڣ�speed:-100~100��degree:0~65535
+def set_motor_angle(port:bytes,speed:int,degree:int) -> Optional[bytes]:
+    motor_str=[0xA0, 0x01, 0x04, 0x81, 0x00, 0x81, 0x00, 0x00, 0xBE]           
+    motor_str[0]=0XA0+port
+    
+    if speed>100:
+        m_par=100
+    elif speed>=0 and speed<=100:
+        m_par=speed        
+    elif speed<-100:
+        m_par=156
+    elif speed<=0 and speed>=-100:
+        m_par=256+speed
+        
+    motor_str[4]=m_par
+    motor_str[6]=degree//256
+    motor_str[7]=degree%256
+#    response = base_driver.single_operate_sensor(motor_str,0)
+    time.sleep(0.005)
+    base_driver.write_data(0X01, 0X02, motor_str)
+#    if response == None:
+#        return None
+#    else:
+    return 0
+        
+#���ﶨʱת�� port:����M�˿ڣ�speed:-100~100��second:1~256
+def set_motor_second(port:bytes,speed:int,second:float) -> Optional[bytes]:
+    motor_str=[0xA0, 0x01, 0x08, 0x81, 0x00, 0x82, 0x00, 0x00, 0x00, 0x00, 0xBE]           
+    motor_str[0]=0XA0+port
+    
+    if speed>100:
+        m_par=100
+    elif speed>=0 and speed<=100:
+        m_par=speed        
+    elif speed<-100:
+        m_par=156
+    elif speed<=0 and speed>=-100:
+        m_par=256+speed
+        
+    motor_str[4]=m_par    
+    
+    byte_data = struct.pack('f', second)
+    byte_array = list(byte_data)
+    
+    motor_str[6]=byte_array[0]
+    motor_str[7]=byte_array[1]
+    motor_str[8]=byte_array[2]
+    motor_str[9]=byte_array[3]
+    
+#    response = base_driver.single_operate_sensor(motor_str,0)
+    time.sleep(0.005)
+    base_driver.write_data(0X01, 0X02, motor_str)
+#    if response == None:
+#        return None
+#    else:
+    return 0
+
+#���ﶨ��ת�� port:����M�˿ڣ�speed:-100~100
+def set_motor_constspeed(port:bytes,speed:int) -> Optional[bytes]:
+    motor_str=[0xA0, 0x01, 0x09, 0x71, 0x00, 0xBE]           
+    motor_str[0]=0XA0+port
+    
+    if speed>100:
+        m_par=100
+    elif speed>=0 and speed<=100:
+        m_par=speed        
+    elif speed<-100:
+        m_par=156
+    elif speed<=0 and speed>=-100:
+        m_par=256+speed
+        
+    motor_str[4]=m_par
+    
+#    response = base_driver.single_operate_sensor(motor_str,0)
+    time.sleep(0.005)
+    base_driver.write_data(0X01, 0X02, motor_str)
+#    if response == None:
+#        return None
+#    else:
+    return 0
+        
+#�����ٶȶ�ȡ port:����M�˿ڣ�
+def get_motor_speed(port:bytes) -> Optional[bytes]:
+    motor_str=[0xA0, 0x01, 0x10, 0xBE]           
+    motor_str[0]=0XA0+port 
+    time.sleep(0.005)      
+    response = base_driver.single_operate_sensor(motor_str,0)        
+    if response == None:
+        return None
+    else:
+        code_data=response[4:-1]
+        code_num=int.from_bytes(code_data, byteorder='big', signed=True)
+        return code_num   
+
+  
+
+