smartpi 0.1.40__py3-none-any.whl → 0.1.41__py3-none-any.whl

smartpi/ai_vad.py

@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+import sys
+import os
+import time
+import numpy as np
+import torch
+
+# 设置环境变量以优化性能
+os.environ['OMP_NUM_THREADS'] = '1'
+os.environ['KMP_AFFINITY'] = 'disabled'
+
+class VADProviderBase:
+    """VAD provider base class"""
+    @staticmethod
+    def create_vad_instance(
+        class_name: str = "silero", 
+        model_dir=None, 
+        threshold=0.5, 
+        min_silence_duration_ms=800,
+        energy_threshold=0.02
+    ):
+        """Factory method to create VAD instance"""
+        if class_name == "silero":
+            try:
+                return SileroVADProvider(
+                    model_dir=model_dir, 
+                    threshold=threshold, 
+                    min_silence_duration_ms=min_silence_duration_ms
+                )
+            except Exception as e:
+                print(f"Failed to create SileroVAD instance: {e}")
+                print("Falling back to EnergyVADProvider...")
+                return EnergyVADProvider(
+                    threshold=energy_threshold, 
+                    min_silence_duration_ms=min_silence_duration_ms
+                )
+        elif class_name == "energy":
+            return EnergyVADProvider(
+                threshold=energy_threshold, 
+                min_silence_duration_ms=min_silence_duration_ms
+            )
+        raise ValueError(f"Unsupported VAD type: {class_name}")
+
+class SileroVADProvider(VADProviderBase):
+    """Silero VAD provider"""
+    def __init__(self, model_dir=None, threshold=0.5, min_silence_duration_ms=800):
+        # 获取模型目录，默认为当前文件所在目录下的models/snakers4_silero-vad
+        if not model_dir:
+            model_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "models/snakers4_silero-vad")
+        
+        print(f"Initializing SileroVAD: model_dir={model_dir}, threshold={threshold}, min_silence_duration_ms={min_silence_duration_ms}")
+        
+        # 加载模型
+        try:
+            # 尝试检查torchaudio是否安装
+            import importlib.util
+            torchaudio_available = importlib.util.find_spec('torchaudio') is not None
+            
+            if torchaudio_available:
+                # 如果有torchaudio，使用默认的PyTorch模型
+                self.model, self.utils = torch.hub.load(
+                    repo_or_dir=model_dir,
+                    source="local",
+                    model="silero_vad",
+                    force_reload=False,
+                )
+            else:
+                # 如果没有torchaudio，尝试使用ONNX版本
+                print("torchaudio not found, trying ONNX version...")
+                self.model, self.utils = torch.hub.load(
+                    repo_or_dir=model_dir,
+                    source="local",
+                    model="silero_vad",
+                    onnx=True,
+                    force_reload=False,
+                )
+        except Exception as e:
+            print(f"Failed to load Silero model (both PyTorch and ONNX versions): {e}")
+            # 降级到能量检测
+            raise Exception("Model loading failed, will use energy detection")
+        
+        # 初始化VAD配置，使用默认值作为备选
+        self.vad_threshold = float(threshold) if threshold else 0.5
+        self.silence_threshold_ms = int(min_silence_duration_ms) if min_silence_duration_ms else 800
+        print("SileroVAD初始化成功")
+    
+    def is_vad(self, conn, audio_data):
+        """检测音频数据中的语音活动"""
+        try:
+            # 确保conn对象有必要的属性
+            if not hasattr(conn, 'client_audio_buffer'):
+                conn.client_audio_buffer = []
+            if not hasattr(conn, 'client_have_voice'):
+                conn.client_have_voice = False
+            if not hasattr(conn, 'client_have_voice_last_time'):
+                conn.client_have_voice_last_time = 0
+            if not hasattr(conn, 'client_voice_stop'):
+                conn.client_voice_stop = False
+            
+            # 将新数据加入缓冲区
+            conn.client_audio_buffer.extend(audio_data)
+            
+            # 处理缓冲区中的完整帧（每次处理512采样点，每个采样点2字节）
+            client_have_voice = False
+            while len(conn.client_audio_buffer) >= 512 * 2:
+                # 提取前512个采样点（1024字节）
+                chunk = bytes(conn.client_audio_buffer[:512 * 2])
+                conn.client_audio_buffer = conn.client_audio_buffer[512 * 2:]
+                
+                # 转换为模型需要的格式
+                audio_int16 = np.frombuffer(chunk, dtype=np.int16)
+                audio_float32 = audio_int16.astype(np.float32) / 32768.0
+                
+                # 检测语音活动
+                with torch.no_grad():
+                    speech_prob = self.model(torch.from_numpy(audio_float32), 16000).item()
+                
+                client_have_voice = speech_prob >= self.vad_threshold
+                
+                # 更新VAD状态
+                if client_have_voice:
+                    conn.client_have_voice = True
+                    conn.client_have_voice_last_time = time.time() * 1000
+                    conn.client_voice_stop = False
+                elif conn.client_have_voice:
+                    # 检查静默时间
+                    stop_duration = time.time() * 1000 - conn.client_have_voice_last_time
+                    if stop_duration >= self.silence_threshold_ms:
+                        conn.client_have_voice = False
+                        conn.client_voice_stop = True
+            
+            return client_have_voice
+        except Exception as e:
+            print(f"VAD detection error: {e}")
+            return False
+    
+    def reset_states(self):
+        """Reset VAD states"""
+        pass  # States are now stored in conn object, no need to reset here
+
+class EnergyVADProvider(VADProviderBase):
+    """Audio energy-based VAD provider (fallback solution)"""
+    def __init__(self, threshold=0.02, min_silence_duration_ms=300):
+        print(f"Initializing EnergyVAD: threshold={threshold}, min_silence_duration_ms={min_silence_duration_ms}")
+        # 初始化VAD配置，使用默认值作为备选
+        self.vad_threshold = float(threshold) if threshold else 0.02
+        self.silence_threshold_ms = int(min_silence_duration_ms) if min_silence_duration_ms else 300
+        print("EnergyVAD initialized successfully")
+    
+    def is_vad(self, conn, audio_data):
+        """使用音频能量检测语音活动"""
+        try:
+            # 确保conn对象有必要的属性
+            if not hasattr(conn, 'client_audio_buffer'):
+                conn.client_audio_buffer = []
+            if not hasattr(conn, 'client_have_voice'):
+                conn.client_have_voice = False
+            if not hasattr(conn, 'client_have_voice_last_time'):
+                conn.client_have_voice_last_time = 0
+            if not hasattr(conn, 'client_voice_stop'):
+                conn.client_voice_stop = False
+            
+            # 将新数据加入缓冲区
+            conn.client_audio_buffer.extend(audio_data)
+            
+            # 处理缓冲区中的数据
+            client_have_voice = False
+            # 对于能量检测，我们可以使用较小的块大小，例如256采样点
+            while len(conn.client_audio_buffer) >= 256 * 2:
+                # 提取前256个采样点（512字节）
+                chunk = bytes(conn.client_audio_buffer[:256 * 2])
+                conn.client_audio_buffer = conn.client_audio_buffer[256 * 2:]
+                
+                # 计算能量
+                audio_int16 = np.frombuffer(chunk, dtype=np.int16)
+                energy = np.abs(audio_int16).mean()
+                
+                client_have_voice = energy > self.vad_threshold
+                
+                # 更新VAD状态
+                if client_have_voice:
+                    conn.client_have_voice = True
+                    conn.client_have_voice_last_time = time.time() * 1000
+                    conn.client_voice_stop = False
+                elif conn.client_have_voice:
+                    # 检查静默时间
+                    stop_duration = time.time() * 1000 - conn.client_have_voice_last_time
+                    if stop_duration >= self.silence_threshold_ms:
+                        conn.client_have_voice = False
+                        conn.client_voice_stop = True
+            
+            return client_have_voice
+        except Exception as e:
+            print(f"能量检测出错: {e}")
+            return False
+    
+    def reset_states(self):
+        """重置VAD状态"""
+        pass  # 状态现在存储在conn对象中，不需要在这里重置

smartpi/base_driver.py

@@ -130,14 +130,15 @@ def write_data(command_h: int, command_l: int, send_data: bytes= None, lock: byt
             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")
+        print("send:")
+        for x in send_bytes:
+            print(f"{x:02X}", end=' ')
+        print("\n")
         buf_clear()
         serial_lock.acquire()  #获取线程锁
         fcntl.flock(ser.fileno(), fcntl.LOCK_EX)  #进程锁，阻塞其他进程
         ser.write(send_bytes)
-        serial_lock.release()  #释放线程锁
+        serial_lock.release()  #释放线程锁 
         fcntl.flock(ser.fileno(), fcntl.LOCK_UN)  # 释放进程锁
     elif lock == False:
         buffer = bytearray()
@@ -152,9 +153,10 @@ def write_data(command_h: int, command_l: int, send_data: bytes= None, lock: byt
             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")
+        print("send:")
+        for x in send_bytes:      
+            print(f"{x:02X}", end=' ')
+        print("\n")
         buf_clear()
         ser.write(send_bytes)
                  
@@ -502,11 +504,7 @@ def mode_change(send_data: str) -> Optional[bytes]:
                 return None
                 
 def shut_down():
-    serial_lock.acquire()  #获取线程锁
-    fcntl.flock(ser.fileno(), fcntl.LOCK_EX)  # 进程锁，阻塞其他进程
     write_data(0XFF, 0XFE)
-    serial_lock.release()  #释放线程锁
-    fcntl.flock(ser.fileno(), fcntl.LOCK_UN)  # 释放进程锁
     time.sleep(0.5)
         
 def power_button_detec() -> bytes:
@@ -551,6 +549,262 @@ def buf_clear():
         fcntl.ioctl(ser.fileno(), termios.TCIOFLUSH)
     except:
         pass
+        
+        
+def enter_bootloader_mode():
+    """进入Bootloader模式"""
+    serial_lock.acquire()  #获取线程锁
+    fcntl.flock(ser.fileno(), fcntl.LOCK_EX)  #进程锁，阻塞其他进程           
+    write_data(BOOT_UPDATE_H, BOOT_UPDATE_L, None, False)
+    start_time = time.time()
+    while True:
+        response =process_received_data()
+        if response:
+            serial_lock.release()  #释放线程锁
+            fcntl.flock(ser.fileno(), fcntl.LOCK_UN)  # 释放进程锁
+            buf_clear()
+            print("get:")
+            for x in response:
+                print(f"{x:02X}", end=' ')
+            print("\n")
+            return True
+        else:
+            if time.time() - start_time > 2:  
+                print("读取超时")
+                buf_clear()
+                serial_lock.release()  #释放线程锁
+                fcntl.flock(ser.fileno(), fcntl.LOCK_UN)  # 释放进程锁
+                return None  
+
+def send_update_request():
+    """发送更新请求"""
+    serial_lock.acquire()  #获取线程锁
+    fcntl.flock(ser.fileno(), fcntl.LOCK_EX)  #进程锁，阻塞其他进程           
+    write_data(UPDATE_REQUEST_H, UPDATE_REQUEST_L, None, False)
+    start_time = time.time()
+    while True:
+        response = process_received_data()
+        if response:
+            serial_lock.release()  #释放线程锁
+            fcntl.flock(ser.fileno(), fcntl.LOCK_UN)  # 释放进程锁
+            buf_clear()
+            print("get:")
+            for x in response:
+                print(f"{x:02X}", end=' ')
+            print("\n")
+            return True
+        else:
+            if time.time() - start_time > 2:  
+                print("更新请求超时")
+                buf_clear()
+                serial_lock.release()  #释放线程锁
+                fcntl.flock(ser.fileno(), fcntl.LOCK_UN)  # 释放进程锁
+                return None
+
+def send_file_size(file_size):
+    """发送文件大小"""
+    serial_lock.acquire()  #获取线程锁
+    fcntl.flock(ser.fileno(), fcntl.LOCK_EX)  #进程锁，阻塞其他进程
+    
+    try:
+        # 将文件大小转换为4字节小端序
+        size_data = struct.pack('<I', file_size)
+        write_data(MAX_COM_LEN_H, MAX_COM_LEN_L, size_data, False)
+        
+        start_time = time.time()
+        while True:
+            response = process_received_data()
+            if response:
+                serial_lock.release()  #释放线程锁
+                fcntl.flock(ser.fileno(), fcntl.LOCK_UN)  # 释放进程锁
+                buf_clear()
+                for x in response:
+                    print(f"{x:02X}", end=' ')
+                print("\n")
+                return True
+            else:
+                if time.time() - start_time > 2:  
+                    print("发送文件大小超时")
+                    buf_clear()
+                    serial_lock.release()  #释放线程锁
+                    fcntl.flock(ser.fileno(), fcntl.LOCK_UN)  # 释放进程锁
+                    return None
+    except Exception as e:
+        print(f"发送文件大小出错: {e}")
+        serial_lock.release()  #释放线程锁
+        fcntl.flock(ser.fileno(), fcntl.LOCK_UN)  # 释放进程锁
+        return None
+
+def send_file_data_chunk(chunk_data, chunk_num, total_chunks):
+    """发送文件数据块"""
+    serial_lock.acquire()  #获取线程锁
+    fcntl.flock(ser.fileno(), fcntl.LOCK_EX)  #进程锁，阻塞其他进程
+    
+    try:
+        write_data(PAGE_SEND_H, PAGE_SEND_L, chunk_data, False)
+        
+        start_time = time.time()
+        while True:
+            response = process_received_data()
+            if response:
+                serial_lock.release()  #释放线程锁
+                fcntl.flock(ser.fileno(), fcntl.LOCK_UN)  # 释放进程锁
+                buf_clear()
+                # 显示进度
+                progress = (chunk_num + 1) * 100 // total_chunks
+                if progress % 10 == 0 or chunk_num == total_chunks - 1:
+                    print(f"传输进度: {progress}% ({chunk_num+1}/{total_chunks})")
+                return True
+            else:
+                if time.time() - start_time > 2:  
+                    print(f"第{chunk_num+1}块数据发送超时")
+                    buf_clear()
+                    serial_lock.release()  #释放线程锁
+                    fcntl.flock(ser.fileno(), fcntl.LOCK_UN)  # 释放进程锁
+                    return None
+    except Exception as e:
+        print(f"发送数据块出错: {e}")
+        serial_lock.release()  #释放线程锁
+        fcntl.flock(ser.fileno(), fcntl.LOCK_UN)  # 释放进程锁
+        return None
+
+def send_restart_command():
+    """发送重启命令"""
+    print("发送重启指令...")
+    serial_lock.acquire()
+    fcntl.flock(ser.fileno(), fcntl.LOCK_EX)
+    
+    try:
+        # 发送重启命令 (0xFF 0xFF)
+        write_data(0xFF, 0xFF, None, False)
+        
+        # 重启不需要等待响应，因为设备会立即重启
+        time.sleep(0.5)
+        print("重启指令已发送")
+        return True
+    except Exception as e:
+        print(f"发送重启指令出错: {e}")
+        return False
+    finally:
+        serial_lock.release()
+        fcntl.flock(ser.fileno(), fcntl.LOCK_UN)
+
+def transmit_file_to_usb(file_path, chunk_size=512):
+    """
+    传输文件到虚拟U盘的主函数
+    
+    Args:
+        file_path: 要传输的文件路径
+        chunk_size: 每个数据块的大小（默认512字节）
+    
+    Returns:
+        bool: 传输是否成功
+    """
+    print("=" * 50)
+    print("开始文件传输到虚拟U盘")
+    print("=" * 50)
+    
+    # 检查文件是否存在
+    if not os.path.exists(file_path):
+        print(f"错误: 文件不存在 - {file_path}")
+        return False
+    
+    # 获取文件大小
+    try:
+        file_size = os.path.getsize(file_path)
+        print(f"文件: {os.path.basename(file_path)}")
+        print(f"大小: {file_size} 字节")
+    except Exception as e:
+        print(f"获取文件大小出错: {e}")
+        return False
+    
+    # 确保串口已初始化
+    if not ser.is_open:
+        print("初始化串口...")
+        uart3_init()
+        if not ser.is_open:
+            print("串口初始化失败")
+            return False
+    
+    # 1. 进入Bootloader模式
+    enter_bootloader_mode()
+        
+    time.sleep(5)
+    
+    # 2. 发送更新请求
+    if not send_update_request():
+        print("更新请求失败，传输中止")
+        return False
+    
+#    # 3. 发送文件大小
+#    if not send_file_size(file_size):
+#        print("文件大小发送失败，传输中止")
+#        return False
+#    
+#    # 4. 读取并发送文件数据
+#    print("开始传输文件数据...")
+#    try:
+#        with open(file_path, 'rb') as f:
+#            total_chunks = (file_size + chunk_size - 1) // chunk_size
+#            
+#            for chunk_num in range(total_chunks):
+#                # 读取数据块
+#                chunk_data = f.read(chunk_size)
+#                if not chunk_data:
+#                    print(f"错误: 第{chunk_num+1}块数据读取失败")
+#                    return False
+#                
+#                # 如果数据块不足chunk_size，填充0（可选）
+#                if len(chunk_data) < chunk_size:
+#                    chunk_data += b'\x00' * (chunk_size - len(chunk_data))
+#                
+#                # 发送数据块
+#                if not send_file_data_chunk(chunk_data, chunk_num, total_chunks):
+#                    print(f"第{chunk_num+1}块数据发送失败，传输中止")
+#                    return False
+#        
+#        print("文件数据传输完成!")
+#        
+#    except Exception as e:
+#        print(f"读取或发送文件数据出错: {e}")
+#        return False
+#    
+#    # 5. 发送重启命令
+#    if not send_restart_command():
+#        print("重启指令发送失败")
+#        return False
+#    
+#    print("=" * 50)
+#    print("文件传输成功完成!")
+#    print("文件已保存到虚拟U盘")
+#    print("设备将自动重启...")
+#    print("=" * 50)
+    
+    # 等待设备重启
+    time.sleep(3)
+    return True
+    
+def example_file_transfer():
+    """文件传输使用示例"""
+    print("文件传输示例")
+    print("-" * 30)
+    
+    # 初始化串口
+    uart3_init()
+    
+    # 指定要传输的文件路径
+    # 请根据实际情况修改
+    file_path = "/home/zmrobo/UPDATE.DAT"
+    
+    # 执行文件传输
+    success = transmit_file_to_usb(file_path)
+    
+    if success:
+        print("文件传输成功！")
+        return 0
+    else:
+        print("文件传输失败！")
+        return 1
     
 """H2-RCU初始化"""
 def smartpi_init():