smartpi 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

smartpi/__init__.py

@@ -1,4 +1,4 @@
 __all__ = ["base_driver"]
 
-__version__ = "0.1.13"
+__version__ = "0.1.15"
 

smartpi/base_driver.py

@@ -1,9 +1,11 @@
 # coding=utf-8
-import serial,time,struct
+import serial,time,struct,threading
 from typing import List, Optional
 from collections import deque
 from . import servo,motor,cw2015,gui
 
+# 创建全局线程锁
+serial_lock = threading.RLock()
 
 # 命令常量
 BOOT_UPDATE_H = 0XFF
@@ -66,10 +68,16 @@ ser = serial.Serial(
             stopbits=serial.STOPBITS_ONE,  # 1位停止位
             timeout=TIMEOUT,
             xonxoff=False,  # 关闭软件流控
-            rtscts=False,   # 关闭硬件流控
-        
+            rtscts=False,   # 关闭硬件流控        
         )
 
+def is_lock_locked(lock):
+    """检查锁是否被占用"""
+    acquired = serial_lock.acquire(blocking=True)
+    if acquired:
+        serial_lock.release()
+        return False
+    return True
 
 def uart3_init() -> Optional[serial.Serial]:
     """初始化串口"""
@@ -94,20 +102,25 @@ def calculate_pro_check(command_h: int, command_l: int, data: List[bytes] = None
         
     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 = 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 = 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 write_data(command_h: int, command_l: int, send_data: bytes= None) -> Optional[bytes]:
+    #with serial_lock:                   
+        buffer = bytearray()
+        HEADER = bytes.fromhex('86 AB')  # 帧头
+        FOOTER = bytes.fromhex('CF')     # 帧尾
+        MIN_FRAME_LEN = 9                # 最小帧长度           
+        if send_data:            
+            pro_check = 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 = 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)
+        
+#        for x in send_bytes:
+#            print(f"{x:02X}", end=' ')
+#        print("\n")
+        
+        ser.write(send_bytes)
                  
         
 def check_frame(frame: bytes) -> bool:
@@ -122,85 +135,79 @@ def check_frame(frame: bytes) -> bool:
     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:
+    #with serial_lock:
+        global buffer
+        # 读取所有可用数据
+        data = ser.read(ser.in_waiting or 1)
+        
+#        if data:
+#            buffer.extend(data)
+#            
+#            # 检查缓冲区中是否有0xCF
+#            if 0xCF in buffer:
+#                # 找到0xCF的位置
+#                cf_index = buffer.index(0xCF)
+#                # 提取从开始到0xCF的完整帧（包括0xCF）
+#                frame = buffer[:cf_index + 1]
+#                # 从缓冲区中移除已处理的数据
+#                buffer = buffer[cf_index + 1:]
+#                return bytes(frame)          
+        
+        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 check_frame(frame):
-            return frame
-        else:
-            print("Check byte error")
+            # 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 check_frame(frame):
+                return frame
+            else:
+                print("Check byte error")
                 
 # 功能函数类
 ##############################################################################读取设备信息
-"""固件升级模式"""
-def boot_update() -> None:
-    write_data(BOOT_UPDATE_H, BOOT_UPDATE_L)       
-    while True:
-        response =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]:
+    serial_lock.acquire()  #获取线程锁
     write_data(READ_MODEL_H, READ_MODEL_L)
     start_time = time.time()
     while True:
         response =process_received_data()
         if response:
+            serial_lock.release()  #释放线程锁
             display_data = response[6:-3].decode(errors="ignore")
 #            print(f"设备型号: {display_data}")
             return display_data
@@ -208,15 +215,18 @@ def read_device_model() -> Optional[bytes]:
             if time.time() - start_time > 3:
                 print("读取超时")
                 buffer.clear() 
+                serial_lock.release()  #释放线程锁
                 return None
 
 """读取版本号"""
 def read_version() -> Optional[bytes]:
+    serial_lock.acquire()  #获取线程锁
     write_data(READ_VERSION_H, READ_VERSION_L)
     start_time = time.time()
     while True:
         response =process_received_data()
         if response:
+            serial_lock.release()  #释放线程锁
             display_data = response[6:-3].decode(errors="ignore")
 #            print(f"版本号: {display_data}")
             return display_data
@@ -224,15 +234,18 @@ def read_version() -> Optional[bytes]:
             if time.time() - start_time > 3:
                 print("读取超时")
                 buffer.clear() 
+                serial_lock.release()  #释放线程锁
                 return None
 
 """读取工厂信息"""
 def read_factory_data() -> Optional[bytes]:
+    serial_lock.acquire()  #获取线程锁
     write_data(READ_FACTORY_H, READ_FACTORY_L)
     start_time = time.time()
     while True:
         response =process_received_data()
         if response:
+            serial_lock.release()  #释放线程锁
             display_data = response[6:-3].decode(errors="ignore")
 #            print(f"厂家信息: {display_data}")
             return display_data
@@ -240,15 +253,18 @@ def read_factory_data() -> Optional[bytes]:
             if time.time() - start_time > 3:
                 print("读取超时")
                 buffer.clear() 
+                serial_lock.release()  #释放线程锁
                 return None
 
 """读取硬件ID"""
 def read_hardware_ID() -> Optional[bytes]:
+    serial_lock.acquire()  #获取线程锁
     write_data(READ_HW_ID_H, READ_HW_ID_L)
     start_time = time.time()
     while True:
         response =process_received_data()
         if response:
+            serial_lock.release()  #释放线程锁
             display_data = response[6:-3].decode(errors="ignore")
 #            print(f"硬件ID: {display_data}")
             return display_data
@@ -256,15 +272,18 @@ def read_hardware_ID() -> Optional[bytes]:
             if time.time() - start_time > 3:
                 print("读取超时")
                 buffer.clear() 
+                serial_lock.release()  #释放线程锁
                 return None
         
 """读取设备名称"""
-def read_device_name() -> Optional[bytes]:        
+def read_device_name() -> Optional[bytes]:
+    serial_lock.acquire()  #获取线程锁        
     write_data(READ_NAME_H, READ_NAME_L)
     start_time = time.time()
     while True:
         response =process_received_data()
         if response:
+            serial_lock.release()  #释放线程锁
             display_data = response[6:-3].decode(errors="ignore")
 #            print(f"设备名称: {display_data}")
             return display_data
@@ -272,16 +291,19 @@ def read_device_name() -> Optional[bytes]:
             if time.time() - start_time > 3:
                 print("读取超时")
                 buffer.clear() 
+                serial_lock.release()  #释放线程锁
                 return None
         
 """设置设备名称"""
 def write_device_name(send_data: str) -> Optional[bytes]:
+    serial_lock.acquire()  #获取线程锁
     data_bytes = send_data.encode('utf-8')
     write_data(WRITE_NAME_H, WRITE_NAME_L, data_bytes)
     start_time = time.time()
     while True:
         response =process_received_data()
         if response:
+            serial_lock.release()  #释放线程锁
             display_data = response[6:-3].decode(errors="ignore")
 #            print(f"设置状态: {display_data}")
             return 0
@@ -289,22 +311,26 @@ def write_device_name(send_data: str) -> Optional[bytes]:
             if time.time() - start_time > 3:
                 print("读取超时")
                 buffer.clear() 
+                serial_lock.release()  #释放线程锁
                 return None
         
 """读取连接方式"""
 def read_connected() -> Optional[bytes]: 
+    serial_lock.acquire()  #获取线程锁
     write_data(READ_CONNECT_H, READ_CONNECT_L)
     start_time = time.time()
     while True:
         response =process_received_data()
         if response:
+            serial_lock.release()  #释放线程锁
             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() 
+                buffer.clear()
+                serial_lock.release()  #释放线程锁 
                 return None
     
 """读取电池电量百分比"""        
@@ -317,39 +343,39 @@ def read_battery() -> Optional[bytes]:
         
 ###############################################################################固件升级
 
-"""下载更新请求"""
-def update_request() -> Optional[bytes]:
-    write_data(UPDATE_REQUEST_H, UPDATE_REQUEST_L)
-    start_time = time.time()
-    while True:
-        response =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 None
-
-"""查询最大通讯长度"""
-def read_max_com_len() -> Optional[bytes]:
-    write_data(MAX_COM_LEN_H, MAX_COM_LEN_L)
-    start_time = time.time()
-    while True:
-        response =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 None
-
-"""下载文件的信息"""
+#"""下载更新请求"""
+#def update_request() -> Optional[bytes]:
+#    write_data(UPDATE_REQUEST_H, UPDATE_REQUEST_L)
+#    start_time = time.time()
+#    while True:
+#        response =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 None
+#
+#"""查询最大通讯长度"""
+#def read_max_com_len() -> Optional[bytes]:
+#    write_data(MAX_COM_LEN_H, MAX_COM_LEN_L)
+#    start_time = time.time()
+#    while True:
+#        response =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 None
+#
+#"""下载文件的信息"""
 #def download_massage() -> Optional[bytes]:
 #    write_data(DL_MESSAGE_H, DL_MESSAGE_L, file_data)#文件信息来源从哪获取？
 #    start_time = time.time()
@@ -416,12 +442,14 @@ def read_max_com_len() -> Optional[bytes]:
 ###############################################################################读取传感器信息
 
 """读取外设连接情况"""
-def read_peripheral() -> Optional[bytes]:   
+def read_peripheral() -> Optional[bytes]: 
+    serial_lock.acquire()  #获取线程锁
     write_data(READ_PERIPH_H, READ_PERIPH_L)
     start_time = time.time()
     while True:
         response =process_received_data()
         if response:
+            serial_lock.release()  #释放线程锁
             display_data = response[6:-3]
 #            for x in display_data:
 #                print(f"{x:02X}", end=' ')
@@ -431,24 +459,28 @@ def read_peripheral() -> Optional[bytes]:
             if time.time() - start_time > 3:
                 print("读取超时")
                 buffer.clear() 
+                serial_lock.release()  #释放线程锁
                 return None
 
 """单次操作外设"""         
-def single_operate_sensor(op_struct: bytes) -> Optional[bytes]:       
+def single_operate_sensor(op_struct: bytes) -> Optional[bytes]:     
+    serial_lock.acquire()  #获取线程锁
     write_data(SINGLE_OP_H, SINGLE_OP_L, op_struct)
     start_time = time.time()
     while True:
         response =process_received_data()
         if response:
+            serial_lock.release()  #释放线程锁
             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:
+            if time.time() - start_time > 2:  
                 print("读取超时")
                 buffer.clear() 
+                serial_lock.release()  #释放线程锁
                 return None  
 
 #P端口初始化释放     
@@ -462,43 +494,54 @@ def P_port_init(port:bytes) -> Optional[bytes]:
         return None
               
 """从机模式转换"""         
-def mode_change(send_data: str) -> Optional[bytes]:     
+def mode_change(send_data: str) -> Optional[bytes]: 
+    serial_lock.acquire()  #获取线程锁    
     write_data(MODE_CHANGE_H, MODE_CHANGE_L, send_data)
     start_time = time.time()
     while True:
         response =process_received_data()
         if response:
+            serial_lock.release()  #释放线程锁
             display_data = response[6:-3]
-            for x in display_data:
-                print(f"{x:02X}", end=' ')
-            print("\n")
+#            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() 
+                serial_lock.release()  #释放线程锁
                 return None
         
 """智能模式发送周期"""         
-def mode_change(send_data: str) -> Optional[bytes]:       
+def mode_change(send_data: str) -> Optional[bytes]:  
+    serial_lock.acquire()  #获取线程锁     
     write_data(SEND_CYCLE_H, SEND_CYCLE_L, send_data)
     start_time = time.time()
     while True:
         response =process_received_data()
         if response:
+            serial_lock.release()  #释放线程锁
             display_data = response[6:-3]
-            for x in display_data:
-                print(f"{x:02X}", end=' ')
-            print("\n")
+#            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() 
+                buffer.clear()
+                serial_lock.release()  #释放线程锁 
                 return None
 
 """H2-RCU初始化"""
 def smartpi_init():
+    
+    if is_lock_locked(serial_lock):
+        serial_lock.release()
+    
+    serial_lock.acquire()
     uart3_init()
     P_port_init(1)
     P_port_init(2)
@@ -531,6 +574,7 @@ def smartpi_init():
     motor.reset_motor_encoder(5)
     motor.reset_motor_encoder(6)
     time.sleep(0.1)
-    gui.init()          
+    gui.init()
+    serial_lock.release()      
     time.sleep(0.1)   
             

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 = 100  # 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/gui.py

@@ -1,97 +1,28 @@
 import socket
 import json
 import sys
-import threading
-import queue
-import atexit
 
 # 连接对象（模块级单例）
 _connection = None
-# 命令队列
-_command_queue = queue.Queue(maxsize=1000)
-# 后台发送线程
-_sender_thread = None
-# 线程停止标志
-_stop_event = threading.Event()
 
 def init(host="127.0.0.1", port=65167):
     """初始化GUI连接"""
-    global _connection, _sender_thread, _stop_event
-    if _connection is None:
-        try:
-            _connection = socket.create_connection((host, port))
-            _connection.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-        except ConnectionRefusedError:
-            print(f"无法连接到GUI服务器 {host}:{port}", file=sys.stderr)
-            return
-        
-        # 启动后台发送线程
-        _stop_event.clear()
-        _sender_thread = threading.Thread(target=_send_worker, daemon=True)
-        _sender_thread.start()
-        _send({"type": "clear"})
-
-def _send_worker():
-    """后台发送线程的工作函数"""
-    while not _stop_event.is_set():
-        try:
-            # 从队列中获取命令，最多等待0.01秒
-            cmd = _command_queue.get(timeout=0.01)
-            
-            if _connection:
-                data = json.dumps(cmd) + "\n"
-                _connection.sendall(data.encode())
-            
-            # 标记任务完成
-            _command_queue.task_done()
-        except queue.Empty:
-            continue
-        except (BrokenPipeError, ConnectionResetError):
-            # 连接断开，尝试重新连接
-            _reconnect()
-        except Exception as e:
-            print(f"发送错误: {e}", file=sys.stderr)
-            time.sleep(0.1)
-
-def _reconnect():
-    """尝试重新连接服务器"""
     global _connection
-    if _connection:
-        try:
-            _connection.close()
-        except:
-            pass
-        _connection = None
-    
-    # 尝试重新连接
-    try:
-        _connection = socket.create_connection(("127.0.0.1", 65167))
-        _connection.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+    if _connection is None:
+        _connection = socket.create_connection((host, port))
         _send({"type": "clear"})
-    except Exception as e:
-        print(f"重新连接失败: {e}", file=sys.stderr)
 
 def _send(cmd):
-    """发送命令到服务器（线程安全）"""
-    # 如果没有连接，直接返回
-    if _connection is None and "pytest" not in sys.modules:
-        return
-    
-    # 将命令放入队列由后台线程发送
-    try:
-        _command_queue.put(cmd, block=False)
-    except queue.Full:
-        # 队列满时丢弃最旧的一条命令
-        try:
-            _command_queue.get_nowait()
-        except queue.Empty:
-            pass
-        _command_queue.put(cmd, block=False)
+    """发送命令到服务器"""
+    if _connection is None and "pytest" not in sys.modules:  # 允许测试环境不初始化
+        raise ConnectionError("GUI not initialized. Call gui.init() first.")
+    if _connection:
+        _connection.sendall((json.dumps(cmd) + "\n").encode())
 
 def show_text(x, y, text, color="black", size=16):
     _send({"type": "text", "x": x, "y": y, "text": text, "color": color, "size": size})
 
-def print(text):
+def print(text):  # 使用print作为函数名，因为调用时使用gui.print()
     _send({"type": "print", "text": text})
 
 def println(text):
@@ -120,18 +51,11 @@ def clear():
 
 def close():
     """关闭GUI连接"""
-    global _connection, _sender_thread, _stop_event
-    # 设置停止事件
-    _stop_event.set()
-    if _sender_thread:
-        # 等待发送线程退出
-        _sender_thread.join(timeout=0.5)
+    global _connection
     if _connection:
-        try:
-            _connection.close()
-        except:
-            pass
+        _connection.close()
         _connection = None
 
 # 注册程序退出时自动关闭连接
+import atexit
 atexit.register(close)

smartpi/light_sensor.py

@@ -3,11 +3,11 @@ import time
 from typing import List, Optional
 from smartpi import base_driver
 
-#����ȡ port:����P�˿ڣ�  �������أ��Ҷ�����; ��ȡ����-1  
+#����ֵ��ȡ port:����P�˿ڣ�  �������أ���ֵ����; ��ȡ����-1  
 def get_value(port:bytes) -> Optional[bytes]:
     light_str=[0xA0, 0x02, 0x00, 0xBE]
     light_str[0]=0XA0+port
-    light_str[2]=1
+    light_str[2]=0x01
     response = base_driver.single_operate_sensor(light_str)       
     if response == None:
         return None
@@ -15,4 +15,41 @@ def get_value(port:bytes) -> Optional[bytes]:
         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
+    response = base_driver.single_operate_sensor(light_str)       
+    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
+    response = base_driver.single_operate_sensor(light_str)       
+    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
+    response = base_driver.single_operate_sensor(light_str)       
+    if response == None:
+        return None
+    else:
+        return response[4]
         

smartpi/trace.py

@@ -0,0 +1,31 @@
+# coding=utf-8
+import time
+from typing import List, Optional
+from smartpi import base_driver
+
+#循迹卡单通道光值读取 port:连接P端口；正常返回：通道光值数据; 读取错误：None  
+def get_analog(port:bytes, chn:bytes) -> Optional[bytes]:
+    trace_str=[0xA0, 0x21, 0x01, 0x71, 0x00, 0xBE]
+    trace_str[0]=0XA0+port
+    trace_str[4]=0x20+chn
+    response = base_driver.single_operate_sensor(trace_str)       
+    if response == None:
+        return None
+    else:
+        trace_data=response[4:-1]
+        trace_num=int.from_bytes(trace_data, byteorder='big', signed=True)
+        return trace_num
+        
+#循迹卡设置全部颜色 port:连接P端口；正常返回：通道光值数据; 读取错误：None  
+def set_color(port:bytes, color:bytes) -> Optional[bytes]:
+    trace_str=[0xA0, 0x20, 0x01, 0x71, 0x00, 0xBE]
+    trace_str[0]=0XA0+port
+    trace_str[4]=color
+    response = base_driver.single_operate_sensor(trace_str)       
+    if response == None:
+        return None
+    else:
+        return response[4]
+
+        
+        

{smartpi-0.1.13.dist-info → smartpi-0.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: smartpi
-Version: 0.1.13
+Version: 0.1.15
 Summary: A library use for H2-RCU
 Author: ZMROBO
 Classifier: Programming Language :: Python :: 3

{smartpi-0.1.13.dist-info → smartpi-0.1.15.dist-info}/RECORD

@@ -1,18 +1,20 @@
-smartpi/__init__.py,sha256=hSlULYmtHrtLpplBFTQagFL4pXXCSoMgkNVFfklgtzc,55
-smartpi/base_driver.py,sha256=FmnwZFqKE2HVUsDoqxXigdX1YlElcY07YkLnlvKY_x8,18033
+smartpi/__init__.py,sha256=dSznPiZfuuDogA_EVuESFxs3sJut0lzCo-ys_AJaccE,55
+smartpi/base_driver.py,sha256=3_dsEM1Sbx43HVICOFZmByHGAjIRbba902GEWsThDSU,20202
 smartpi/color_sensor.py,sha256=sTqD3jApjmc6qHMrDyEy2UjaRt8vhJZNR88vzgUiLKs,496
 smartpi/cw2015.py,sha256=1lAF-pi_ye_ya1AZQS1sjbgsDf7MThO5IAskKsNGBzA,5695
-smartpi/gui.py,sha256=M0VXAxk9VmW8VXSbbcRfOtZUVigWIDn0pEEYZHMTeI0,4416
+smartpi/flash.py,sha256=Luz0TjinQSkx31uVknqfSWkiAiVrqIE2Iba7lk3AOzM,4132
+smartpi/gui.py,sha256=E98_soyWbEf_dwYhXZgMSXrgY5QuYoDTuFCPK63flIQ,2102
 smartpi/humidity.py,sha256=xtALQ_IlcwR2RCYvopCSmeNajB45kQU_ckk6FZ0rqko,497
 smartpi/led.py,sha256=n3_k1jGcQptfGXhezDLaYzH6UptgluP4Ze6qP_Y4WmU,536
-smartpi/light_sensor.py,sha256=kWmoXklYS1QG0eDz4Qn9FF4WueR3GARb3OwQSkXqUNA,569
+smartpi/light_sensor.py,sha256=glDa4O0wW0kamb-tI3qf509qM7zA8UUjVXbA9si3TXM,1844
 smartpi/motor.py,sha256=uvuAwt2j5LjdLaMfNisXqaGh1ro3fZDvHU8IXd2fn9Q,4527
 smartpi/move.py,sha256=3qzrJCGA-qbsLXBpklY2DErtw0jlzMELzozjhEvRzKs,6028
 smartpi/servo.py,sha256=B6X3yCoEz82qqpUIE5MSO0Eg9YZJ5zDzJEcRpioZpUo,4625
 smartpi/temperature.py,sha256=px2YeqgG63nPkyhJA1wDg3dwYx_oOCYuhMjtsVm_YO0,460
 smartpi/touch_sensor.py,sha256=F6IIQGewNRhC9U1RbHpVzuGYqb8H41lpeQ1Ejwsc_T8,438
+smartpi/trace.py,sha256=pa85IKqNzqAPGtRAoGGYwYmTh3RXOtuKnLrv9_z9qmM,1095
 smartpi/ultrasonic.py,sha256=0meczFKXFLUt92kLxipeEc37vb5duvJjPs4kgtlpO8M,622
-smartpi-0.1.13.dist-info/METADATA,sha256=fyS1LxSRoLa2FGN9JpZ7QYayqJ6zx57Nyt_mTBP6JI0,311
-smartpi-0.1.13.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-smartpi-0.1.13.dist-info/top_level.txt,sha256=PoLhUCmWAiQUg5UeN2fS-Y1iQyBbF2rdUlizXtpHGRQ,8
-smartpi-0.1.13.dist-info/RECORD,,
+smartpi-0.1.15.dist-info/METADATA,sha256=OVWU7rX_t-hjb8WDnOQKBCfmW7Sh17APIuXUs7A9cnM,311
+smartpi-0.1.15.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+smartpi-0.1.15.dist-info/top_level.txt,sha256=PoLhUCmWAiQUg5UeN2fS-Y1iQyBbF2rdUlizXtpHGRQ,8
+smartpi-0.1.15.dist-info/RECORD,,