实验指导书

# 导入需要的库
from gpiozero import LED
import time

# 定义 LED 连接在 GPIO17 引脚
led = LED(17)

# 循环 10 次
for i in range(10):
    print(f"第 {i+1} 次闪烁")
    led.on()      # 开灯
    time.sleep(0.5) # 等 0.5 秒
    led.off()     # 关灯
    time.sleep(0.5) # 再等 0.5 秒

print("闪烁完成！")

import pyaudio
import pvporcupine
from gpiozero import LED
import time

# ========== 配置 ==========
ACCESS_KEY = "你的AccessKey"   # 替换成你自己的
KEYWORD = "hey siri"            # 内置唤醒词，可选: "alexa", "hey google", "picovoice", "porcupine", "bumblebee"
LED_PIN = 17                         # LED 引脚
SENSITIVITY = 0.5                    # 灵敏度，0~1，越高越灵敏但也容易误触发

# ========== 初始化 ==========
led = LED(LED_PIN)

# 创建 Porcupine 实例
porcupine = pvporcupine.create(
    access_key=ACCESS_KEY,
    keywords=[KEYWORD],
    sensitivities=[SENSITIVITY]
)

# 初始化音频输入
pa = pyaudio.PyAudio()
audio_stream = pa.open(
    rate=porcupine.sample_rate,
    channels=1,
    format=pyaudio.paInt16,
    input=True,
    frames_per_buffer=porcupine.frame_length
)

print(f"已启动，说 'Hey Siri' 来唤醒我！")
print("按 Ctrl+C 退出")

# ========== 主循环 ==========
try:
    while True:
        # 读取一帧音频
        pcm = audio_stream.read(porcupine.frame_length)
        pcm = list(__import__('struct').unpack_from("h" * porcupine.frame_length, pcm))

        # 送入 Porcupine 检测
        keyword_index = porcupine.process(pcm)

        # 如果检测到唤醒词
        if keyword_index >= 0:
            print("✨ 检测到唤醒词！")
            led.on()                 # LED 亮
            time.sleep(1)            # 亮 1 秒
            led.off()                # LED 灭

except KeyboardInterrupt:
    print("\n程序已停止")

finally:
    # 清理资源
    audio_stream.close()
    pa.terminate()
    porcupine.delete()

import pyaudio
import numpy as np
import wave

# 配置
CHANNELS = 4
RATE = 16000
RECORD_SECONDS = 3
WAVE_OUTPUT_FILENAME = "record_4ch.wav"
DEVICE_INDEX = None   # 如果有多个设备，指定 ReSpeaker 的设备号

pa = pyaudio.PyAudio()

# 查找 ReSpeaker 设备
for i in range(pa.get_device_count()):
    dev = pa.get_device_info_by_index(i)
    if "seeed" in dev['name'].lower() or "4mic" in dev['name'].lower():
        DEVICE_INDEX = i
        print(f"找到设备: {dev['name']}, 设备号: {i}")

if DEVICE_INDEX is None:
    print("没找到 ReSpeaker 设备，请检查驱动")
    exit()

# 开始录音
stream = pa.open(rate=RATE, channels=CHANNELS,
                 format=pyaudio.paInt16, input=True,
                 input_device_index=DEVICE_INDEX,
                 frames_per_buffer=1024)

print("* 录音中...")
frames = []
for i in range(int(RATE / 1024 * RECORD_SECONDS)):
    data = stream.read(1024)
    frames.append(data)
print("* 录音结束")

stream.stop_stream()
stream.close()
pa.terminate()

# 保存为 WAV 文件
wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
wf.setnchannels(CHANNELS)
wf.setsampwidth(pa.get_sample_size(pyaudio.paInt16))
wf.setframerate(RATE)
wf.writeframes(b''.join(frames))
wf.close()

print(f"已保存到 {WAVE_OUTPUT_FILENAME}")

import numpy as np
from scipy.signal import fftconvolve

def gcc_phat(sig1, sig2, fs, max_tau=None):
    """
    用 GCC-PHAT 算法计算两路信号的时间差
    sig1, sig2: 两路音频信号 (numpy 数组)
    fs: 采样率
    max_tau: 最大可能的时间差（秒），None 表示不限制
    返回: 时间差（秒），正数表示 sig2 比 sig1 晚
    """
    n = sig1.shape[0] + sig2.shape[0]

    # 做 FFT
    SIG1 = np.fft.rfft(sig1, n=n)
    SIG2 = np.fft.rfft(sig2, n=n)

    # PHAT 加权：只保留相位信息
    R = SIG1 * np.conj(SIG2)
    cc = np.fft.irfft(R / np.abs(R), n=n)

    # 找到互相关的峰值位置
    max_shift = int(n / 2)
    if max_tau is not None:
        max_shift = np.minimum(int(fs * max_tau), max_shift)

    cc = np.concatenate((cc[-max_shift:], cc[:max_shift + 1]))
    shift = np.argmax(np.abs(cc)) - max_shift
    tau = shift / float(fs)

    return tau


# ========== 测试一下 ==========
if __name__ == "__main__":
    fs = 16000
    t = np.arange(0, 0.5, 1/fs)

    # 生成一个测试信号（1kHz 正弦波）
    sig1 = np.sin(2 * np.pi * 1000 * t)

    # 把 sig1 延迟 20 个采样点，模拟第二个麦克风的信号
    delay_samples = 20
    sig2 = np.roll(sig1, delay_samples)

    # 加一点噪声
    sig2 += 0.01 * np.random.randn(len(sig2))

    # 计算时间差
    tau = gcc_phat(sig1, sig2, fs)
    print(f"真实延迟: {delay_samples} 个采样点 = {delay_samples/fs*1000:.3f} ms")
    print(f"检测到的时间差: {tau*1000:.3f} ms")
    print(f"检测到的采样差: {tau*fs:.1f} 个采样点")

import numpy as np
from gcc_phat import gcc_phat

# 已知参数
MIC_DISTANCE = 0.10    # 麦克风间距，单位：米（10cm）
SOUND_SPEED = 340       # 声速，单位：米/秒
SAMPLE_RATE = 16000     # 采样率

def calculate_doa(sig_left, sig_right):
    """
    根据左右两个麦克风的信号，计算声源方向角
    返回: 角度（度），范围 -90 ~ 90，0 表示正前方
    """
    # 计算时间差
    max_tau = MIC_DISTANCE / SOUND_SPEED  # 最大可能时间差
    tau = gcc_phat(sig_left, sig_right, SAMPLE_RATE, max_tau=max_tau)

    # 计算 sin(theta)
    sin_theta = (tau * SOUND_SPEED) / MIC_DISTANCE

    # 数值范围保护（避免浮点误差导致超出 [-1,1]）
    sin_theta = np.clip(sin_theta, -1, 1)

    # 转成角度
    theta = np.arcsin(sin_theta) * 180 / np.pi

    return theta


# ========== 测试 ==========
if __name__ == "__main__":
    # 模拟：声源在 30 度方向
    true_angle = 30  # 度
    print(f"真实角度: {true_angle}°")

    # 计算对应的时间差
    delay_seconds = MIC_DISTANCE * np.sin(true_angle * np.pi / 180) / SOUND_SPEED
    delay_samples = int(delay_seconds * SAMPLE_RATE)
    print(f"对应时间差: {delay_seconds*1000:.3f} ms = {delay_samples} 个采样点")

    # 生成测试信号
    t = np.arange(0, 0.5, 1/SAMPLE_RATE)
    sig_left = np.sin(2 * np.pi * 1000 * t)
    sig_right = np.roll(sig_left, delay_samples)

    # 估计角度
    estimated_angle = calculate_doa(sig_left, sig_right)
    print(f"估计角度: {estimated_angle:.1f}°")
    print(f"误差: {abs(estimated_angle - true_angle):.1f}°")

from adafruit_servokit import ServoKit
import time

# 初始化 16 通道舵机驱动板
kit = ServoKit(channels=16)

# 设置第 0 号通道的舵机角度范围（根据你的舵机调整）
kit.servo[0].actuation_range = 180
kit.servo[0].set_pulse_width_range(500, 2500)  # 0.5ms ~ 2.5ms

print("舵机测试开始，按 Ctrl+C 停止")

try:
    while True:
        # 转到 0 度
        print("0°")
        kit.servo[0].angle = 0
        time.sleep(1)

        # 转到 90 度（中间）
        print("90°")
        kit.servo[0].angle = 90
        time.sleep(1)

        # 转到 180 度
        print("180°")
        kit.servo[0].angle = 180
        time.sleep(1)

        # 缓慢转动
        print("缓慢转动中...")
        for angle in range(0, 181, 5):
            kit.servo[0].angle = angle
            time.sleep(0.05)

        for angle in range(180, -1, -5):
            kit.servo[0].angle = angle
            time.sleep(0.05)

except KeyboardInterrupt:
    print("\n测试结束")

import numpy as np

class KalmanFilter1D:
    """
    一维卡尔曼滤波器，用于平滑角度数据
    状态量: [角度, 角速度]
    """
    def __init__(self, x0=0, v0=0, dt=0.1):
        self.dt = dt    # 时间步长（秒）

        # 状态向量 [角度, 角速度]
        self.x = np.array([x0, v0])

        # 状态转移矩阵（匀速运动模型）
        self.F = np.array([[1, dt],
                           [0, 1]])

        # 观测矩阵（我们只能观测到角度）
        self.H = np.array([[1, 0]])

        # 过程噪声协方差（模型的不确定性）
        self.Q = np.array([[0.1, 0],
                           [0, 0.1]])

        # 测量噪声协方差（传感器的不确定性）
        self.R = np.array([[10.0]])

        # 估计误差协方差
        self.P = np.eye(2) * 10

    def predict(self):
        """预测步骤：根据上一状态推测当前状态"""
        self.x = self.F @ self.x                     # 状态预测
        self.P = self.F @ self.P @ self.F.T + self.Q # 误差协方差预测
        return self.x[0]  # 返回预测的角度

    def update(self, z):
        """更新步骤：用测量值修正预测"""
        # 计算卡尔曼增益 K
        S = self.H @ self.P @ self.H.T + self.R
        K = self.P @ self.H.T @ np.linalg.inv(S)

        # 更新状态
        y = z - self.H @ self.x   # 测量残差（测量值 - 预测值）
        self.x = self.x + K @ y

        # 更新误差协方差
        I = np.eye(len(self.x))
        self.P = (I - K @ self.H) @ self.P

        return self.x[0]  # 返回更新后的角度

    def step(self, measurement):
        """执行一次完整的预测+更新"""
        self.predict()
        return self.update(measurement)


# ========== 测试 ==========
if __name__ == "__main__":
    import matplotlib.pyplot as plt

    # 模拟：真实角度是一个从 0° 缓慢转到 60° 的过程
    true_angle = np.linspace(0, 60, 100)

    # 加上噪声模拟测量值
    np.random.seed(42)
    measured_angle = true_angle + np.random.normal(0, 8, 100)  # 8° 的测量噪声

    # 卡尔曼滤波
    kf = KalmanFilter1D(x0=0, v0=0, dt=0.1)
    filtered_angle = []
    for z in measured_angle:
        filtered_angle.append(kf.step(z))
    filtered_angle = np.array(filtered_angle)

    # 画图
    plt.figure(figsize=(10, 5))
    plt.plot(true_angle, label='真实角度', linewidth=2)
    plt.plot(measured_angle, label='测量值（带噪声）', alpha=0.6)
    plt.plot(filtered_angle, label='卡尔曼滤波后', linewidth=2)
    plt.xlabel('时间步')
    plt.ylabel('角度 (°)')
    plt.legend()
    plt.title('卡尔曼滤波效果对比')
    plt.grid(alpha=0.3)
    plt.savefig('kalman_result.png')
    print("图像已保存为 kalman_result.png")

    # 计算误差
    err_measured = np.mean(np.abs(measured_angle - true_angle))
    err_filtered = np.mean(np.abs(filtered_angle - true_angle))
    print(f"测量值平均误差: {err_measured:.2f}°")
    print(f"滤波后平均误差: {err_filtered:.2f}°")

import time
import numpy as np
from adafruit_servokit import ServoKit
from kalman_filter import KalmanFilter1D

# 初始化舵机
kit = ServoKit(channels=16)
kit.servo[0].actuation_range = 180
kit.servo[0].set_pulse_width_range(500, 2500)

# 初始化卡尔曼滤波器
kf = KalmanFilter1D(x0=90, v0=0, dt=0.05)  # 初始角度 90°，20Hz 更新

# 模拟：真实角度在 30°~150° 之间缓慢移动
t = 0
dt = 0.05

print("=== 第一阶段：直接用带噪声的测量值控制舵机 ===")
print("观察舵机是不是抖得很厉害？")
time.sleep(2)

for i in range(100):
    # 真实角度（正弦运动）
    true_angle = 90 + 40 * np.sin(2 * np.pi * 0.2 * t)

    # 加噪声模拟测量值
    noisy_angle = true_angle + np.random.normal(0, 10)  # 10° 噪声

    # 限制在 0~180 范围内
    noisy_angle = np.clip(noisy_angle, 0, 180)

    # 直接控制舵机
    kit.servo[0].angle = noisy_angle

    t += dt
    time.sleep(dt)

time.sleep(1)
print("\n=== 第二阶段：卡尔曼滤波后再控制舵机 ===")
print("观察舵机是不是平稳多了？")
time.sleep(2)

t = 0
kf2 = KalmanFilter1D(x0=90, v0=0, dt=dt)

for i in range(100):
    true_angle = 90 + 40 * np.sin(2 * np.pi * 0.2 * t)
    noisy_angle = true_angle + np.random.normal(0, 10)
    noisy_angle = np.clip(noisy_angle, 0, 180)

    # 卡尔曼滤波
    smooth_angle = kf2.step(noisy_angle)
    smooth_angle = np.clip(smooth_angle, 0, 180)

    # 控制舵机
    kit.servo[0].angle = smooth_angle

    t += dt
    time.sleep(dt)

print("\n演示结束！")

import cv2
import mediapipe as mp

# 初始化 MediaPipe Face Detection
mp_face = mp.solutions.face_detection
face_detection = mp_face.FaceDetection(
    model_selection=0,  # 0=近距离（2m内），1=远距离
    min_detection_confidence=0.5
)

# 打开摄像头
cap = cv2.VideoCapture(0)

print("按 q 键退出")

while cap.isOpened():
    ret, frame = cap.read()
    if not ret: break

    # 转 RGB（MediaPipe 需要 RGB 格式）
    rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    results = face_detection.process(rgb)

    # 画检测结果
    h, w = frame.shape[:2]
    if results.detections:
        for det in results.detections:
            bbox = det.location_data.relative_bounding_box
            x = int(bbox.xmin * w)
            y = int(bbox.ymin * h)
            bw = int(bbox.width * w)
            bh = int(bbox.height * h)

            # 画人脸框
            cv2.rectangle(frame, (x, y), (x+bw, y+bh), (0, 255, 0), 2)

            # 画人脸中心点
            cx, cy = x + bw//2, y + bh//2
            cv2.circle(frame, (cx, cy), 5, (0, 0, 255), -1)

            # 显示置信度
            conf = det.score[0]
            cv2.putText(frame, f'{conf:.2f}', (x, y-10),
                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)

    # 画面中心十字
    cv2.drawMarker(frame, (w//2, h//2), (255, 0, 0),
                   cv2.MARKER_CROSS, 20, 1)

    cv2.imshow('Face Detection', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

import cv2
import mediapipe as mp
from adafruit_servokit import ServoKit
import time

# ===== 配置 =====
PAN_SERVO = 0    # 水平舵机通道
TILT_SERVO = 1   # 垂直舵机通道
Kp = 0.05        # 比例系数（像素→度），需要调试
DEAD_ZONE = 30   # 死区（像素），偏差小于这个值不调整，防止抖

# ===== 初始化舵机 =====
kit = ServoKit(channels=16)
for ch in [PAN_SERVO, TILT_SERVO]:
    kit.servo[ch].actuation_range = 180
    kit.servo[ch].set_pulse_width_range(500, 2500)

pan_angle = 90   # 初始角度：中间
tilt_angle = 90
kit.servo[PAN_SERVO].angle = pan_angle
kit.servo[TILT_SERVO].angle = tilt_angle

# ===== 初始化人脸检测 =====
mp_face = mp.solutions.face_detection
face_detection = mp_face.FaceDetection(model_selection=0, min_detection_confidence=0.6)
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

print("人脸跟踪启动，按 q 退出")

while cap.isOpened():
    ret, frame = cap.read()
    if not ret: break
    h, w = frame.shape[:2]
    center_x, center_y = w // 2, h // 2

    # 检测人脸
    rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    results = face_detection.process(rgb)

    if results.detections:
        # 取第一个检测到的人脸
        det = results.detections[0]
        bbox = det.location_data.relative_bounding_box
        cx = int((bbox.xmin + bbox.width/2) * w)
        cy = int((bbox.ymin + bbox.height/2) * h)

        # 计算偏差
        dx = cx - center_x  # 正=人脸在右边，需要右转
        dy = cy - center_y  # 正=人脸在下边，需要向下

        # 死区：偏差太小就不动，防止抖
        if abs(dx) > DEAD_ZONE:
            pan_angle -= Kp * dx
            pan_angle = max(0, min(180, pan_angle))
            kit.servo[PAN_SERVO].angle = pan_angle

        if abs(dy) > DEAD_ZONE:
            tilt_angle += Kp * dy
            tilt_angle = max(30, min(150, tilt_angle))  # 限制俯仰角度避免卡
            kit.servo[TILT_SERVO].angle = tilt_angle

        # 画图
        cv2.circle(frame, (cx, cy), 8, (0, 0, 255), -1)
        cv2.line(frame, (center_x, center_y), (cx, cy), (255, 255, 0), 2)

    # 画面中心
    cv2.drawMarker(frame, (center_x, center_y), (0, 255, 0),
                   cv2.MARKER_CROSS, 20, 2)

    cv2.putText(frame, f'Pan: {pan_angle:.0f}  Tilt: {tilt_angle:.0f}',
                (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
    cv2.imshow('Face Tracker', frame)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

from funasr import AutoModel

# 加载模型（第一次运行会自动下载，约几百MB）
model = AutoModel(model="paraformer-zh")

# 识别一个 wav 文件
result = model(input="test.wav")

print("识别结果：")
print(result[0]['text'])

import pyaudio
from funasr import AutoModel

# 配置
CHUNK = 1024
FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 16000  # FunASR 要求 16kHz

# 加载流式模型
model = AutoModel(model="paraformer-zh-streaming")

# 打开麦克风
pa = pyaudio.PyAudio()
stream = pa.open(format=FORMAT, channels=CHANNELS,
                 rate=RATE, input=True, frames_per_buffer=CHUNK)

print("开始说话（按 Ctrl+C 停止）：")

cache = {}  # 模型缓存
chunk_size = [0, 10, 5]  # 流式模型的 chunk 配置
chunk_stride = chunk_size[1] * 960  # 每次送入的采样点数

try:
    audio_buf = b''
    while True:
        data = stream.read(CHUNK, exception_on_overflow=False)
        audio_buf += data

        # 积累够一帧就送入模型
        while len(audio_buf) >= chunk_stride * 2:
            chunk = audio_buf[:chunk_stride * 2]
            audio_buf = audio_buf[chunk_stride * 2:]

            result = model(input=chunk, cache=cache,
                           chunk_size=chunk_size,
                           is_final=False)

            # 打印部分结果（不换行，实时更新）
            if result[0]['text']:
                print(f"\r识别中: {result[0]['text']}", end='', flush=True)

except KeyboardInterrupt:
    # 结束时再识别一次，确保最后一句完整
    result = model(input=audio_buf, cache=cache,
                   chunk_size=chunk_size, is_final=True)
    print(f"\n最终结果: {result[0]['text']}")

stream.stop_stream()
stream.close()
pa.terminate()

from openai import OpenAI

# 配置（换成你自己的 API Key 和 base_url）
client = OpenAI(
    api_key="你的APIKey",
    base_url="https://api.deepseek.com/v1"  # 示例：DeepSeek
)

# 对话历史
messages = [
    {"role": "system",
     "content": "你是一个叫'小明'的陪伴机器人，回答要简洁、友好、口语化，每句不超过50字。"}
]

print("小明：你好呀！有什么我能帮你的吗？（输入 quit 退出）")

while True:
    user_input = input("你：")
    if user_input.lower() == "quit":
        break

    # 把用户说的话加入历史
    messages.append({"role": "user", "content": user_input})

    # 调用 LLM
    response = client.chat.completions.create(
        model="deepseek-chat",
        messages=messages,
        temperature=0.7
    )

    reply = response.choices[0].message.content
    print(f"小明：{reply}")

    # 把回答加入历史
    messages.append({"role": "assistant", "content": reply})

import edge_tts
import pygame
import asyncio

async def speak(text, voice="zh-CN-XiaoxiaoNeural"):
    """把文字转成语音并播放"""
    communicate = edge_tts.Communicate(text, voice)
    await communicate.save("response.mp3")

    # 播放
    pygame.mixer.init()
    pygame.mixer.music.load("response.mp3")
    pygame.mixer.music.play()
    while pygame.mixer.music.get_busy():
        pygame.time.Clock().tick(10)

# 使用
asyncio.run(speak("你好呀，我是小明，很高兴认识你！"))

from openai import OpenAI
import json

client = OpenAI(api_key="你的APIKey",
                base_url="https://api.deepseek.com/v1")

# 定义工具：控制舵机转向
tools = [
    {
        "type": "function",
        "function": {
            "name": "turn_servo",
            "description": "控制机器人转向指定的角度方向",
            "parameters": {
                "type": "object",
                "properties": {
                    "angle": {
                        "type": "integer",
                        "description": "转向角度，0-180，90是正前方"
                    },
                    "direction": {
                        "type": "string",
                        "enum": ["left", "right"],
                        "description": "向左转还是向右转"
                    }
                },
                "required": []
            }
        }
    }
]

# 当前舵机角度
current_angle = 90

def turn_servo(angle=None, direction=None):
    global current_angle
    if direction == "left":
        current_angle = max(0, current_angle - 30)
    elif direction == "right":
        current_angle = min(180, current_angle + 30)
    elif angle is not None:
        current_angle = max(0, min(180, angle))

    # 这里可以换成真正控制舵机的代码
    # kit.servo[0].angle = current_angle
    return f"已转到 {current_angle}°"


# 主循环
messages = [
    {"role": "system",
     "content": "你是陪伴机器人小明。用户让你转向时，调用 turn_servo 工具。"}
]

while True:
    user_input = input("你：")
    messages.append({"role": "user", "content": user_input})

    response = client.chat.completions.create(
        model="deepseek-chat",
        messages=messages,
        tools=tools,
        tool_choice="auto"
    )

    msg = response.choices[0].message

    # 如果 LLM 想调用工具
    if msg.tool_calls:
        for tool_call in msg.tool_calls:
            func_name = tool_call.function.name
            args = json.loads(tool_call.function.arguments)
            print(f"[调用工具] {func_name}({args})")

            # 执行函数
            result = turn_servo(**args)

            # 把工具调用和结果加回对话历史
            messages.append(msg)
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "name": func_name,
                "content": result
            })

        # 再调一次 LLM，让它根据工具结果生成最终回答
        response2 = client.chat.completions.create(
            model="deepseek-chat",
            messages=messages
        )
        reply = response2.choices[0].message.content
        messages.append({"role": "assistant", "content": reply})
        print(f"小明：{reply}")
    else:
        # 正常回答
        reply = msg.content
        messages.append({"role": "assistant", "content": reply})
        print(f"小明：{reply}")

import numpy as np
import webrtc_audio_processing as webrtc_ap
import wave

# 读取参考信号（扬声器播放的声音）
def read_wav(path):
    wf = wave.open(path, 'rb')
    data = wf.readframes(wf.getnframes())
    arr = np.frombuffer(data, dtype=np.int16).astype(np.float32) / 32768.0
    sr = wf.getframerate()
    wf.close()
    return arr, sr

# 生成"带回声"的麦克风信号
def simulate_echo(ref_signal, sr, delay_ms=100, echo_gain=0.5):
    delay_samples = int(sr * delay_ms / 1000)
    echo = np.zeros_like(ref_signal)
    echo[delay_samples:] = ref_signal[:-delay_samples] * echo_gain
    # 再加一点混响（简单的多回声模拟）
    for i in range(2, 5):
        d = delay_samples * i
        if d < len(ref_signal):
            echo[d:] += ref_signal[:-d] * echo_gain * (0.5 ** (i-1))
    return echo

# 读取参考音频（找一段 wav 或用实验1录的）
ref, sr = read_wav("test.wav")

# 模拟回声 + 一点人声（这里用噪声代替人声做演示）
echo = simulate_echo(ref, sr, delay_ms=80, echo_gain=0.6)
nearend = 0.1 * np.random.randn(len(ref))  # 模拟近端人声
mic_signal = echo + nearend  # 麦克风信号 = 回声 + 近端人声

# 初始化 AEC
ap = webrtc_ap.AudioProcessing()
ap.set_stream_format(sample_rate_hz=sr, num_channels=1)
ap.set_reverse_stream_format(sample_rate_hz=sr, num_channels=1)
ap.echo_cancellation.enable = True
ap.echo_cancellation.suppression_level = 'high'
ap.initialize()

# 按帧处理（WebRTC 要求 10ms 一帧）
frame_size = int(sr * 0.01)  # 10ms 的采样点数
output = np.zeros_like(mic_signal)

for i in range(0, len(mic_signal) - frame_size, frame_size):
    mic_frame = mic_signal[i:i+frame_size]
    ref_frame = ref[i:i+frame_size]

    # 先喂参考信号
    ap.process_reverse_stream(ref_frame)
    # 再处理麦克风信号
    out_frame = ap.process_stream(mic_frame)

    output[i:i+frame_size] = out_frame

# 计算回声抑制量（能量比）
echo_energy = np.mean(echo ** 2)
out_echo_energy = np.mean((output - nearend) ** 2)
suppression_db = 10 * np.log10(echo_energy / out_echo_energy)
print(f"回声抑制量: {suppression_db:.1f} dB")
print("（越大说明消除得越干净，10dB以上算不错）")

import numpy as np

class DoubleTalkDetector:
    """
    简单的双讲检测器
    原理：比较近端（麦克风）和远端（参考/回声）的能量比
    """
    def __init__(self, threshold=2.0, sr=16000, frame_ms=20):
        self.threshold = threshold  # 能量比阈值
        self.frame_size = int(sr * frame_ms / 1000)
        # 平滑因子，让检测更稳定
        self.alpha = 0.9
        self.mic_energy_smooth = 0
        self.ref_energy_smooth = 0

    def process(self, mic_frame, ref_frame):
        """
        返回 True 表示检测到双讲
        """
        mic_energy = np.mean(mic_frame ** 2)
        ref_energy = np.mean(ref_frame ** 2)

        # 指数平滑
        self.mic_energy_smooth = (self.alpha * self.mic_energy_smooth
                                  + (1 - self.alpha) * mic_energy)
        self.ref_energy_smooth = (self.alpha * self.ref_energy_smooth
                                  + (1 - self.alpha) * ref_energy)

        # 避免除以0
        if self.ref_energy_smooth < 1e-6:
            return False

        # 能量比 = 麦克风能量 / 参考能量
        ratio = self.mic_energy_smooth / self.ref_energy_smooth

        return ratio > self.threshold


# ======== 测试 ========
if __name__ == "__main__":
    sr = 16000
    t = np.arange(0, 3, 1/sr)

    # 参考信号（扬声器一直在说话）
    ref = 0.5 * np.sin(2 * np.pi * 440 * t)

    # 麦克风信号：前1秒只有回声，中间1秒双讲，后1秒只有回声
    mic = 0.3 * ref  # 回声分量
    # 第 1~2 秒加入人声（模拟用户说话）
    voice = np.where((t >= 1) & (t < 2), 0.8 * np.sin(2 * np.pi * 300 * t), 0)
    mic += voice

    # 逐帧检测
    detector = DoubleTalkDetector(threshold=2.0, sr=sr)
    frame_size = detector.frame_size

    print("时间(s)\t双讲?")
    for i in range(0, len(t) - frame_size, frame_size):
        dt = detector.process(mic[i:i+frame_size], ref[i:i+frame_size])
        time_sec = i / sr
        if time_sec % 0.5 < 0.02:  # 每 0.5 秒打印一次
            status = "✅ 双讲" if dt else "  -  仅回声"
            print(f"{time_sec:.1f}\t{status}")

import cv2
import mediapipe as mp
import numpy as np

# 唇部关键点索引（上唇上、下唇下、左嘴角、右嘴角）
LIP_TOP = 13      # 上唇中间（上沿）
LIP_BOTTOM = 14   # 下唇中间（下沿）
LIP_LEFT = 61     # 左嘴角
LIP_RIGHT = 291   # 右嘴角
MOUTH_TOP = 0     # 上唇内侧上沿
MOUTH_BOTTOM = 17 # 下唇内侧下沿

# 初始化 Face Mesh
mp_face_mesh = mp.solutions.face_mesh
face_mesh = mp_face_mesh.FaceMesh(
    max_num_faces=1,
    refine_landmarks=True,   # 开启后嘴唇眼睛更精细
    min_detection_confidence=0.5,
    min_tracking_confidence=0.5
)

cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

# 记录嘴部开合度历史，用来判断"是否在说话"
mouth_ratio_history = []
SPEAKING_THRESHOLD = 0.05  # 嘴高/嘴宽 的变化阈值，需要调试

while cap.isOpened():
    ret, frame = cap.read()
    if not ret: break
    h, w = frame.shape[:2]

    rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    results = face_mesh.process(rgb)

    if results.multi_face_landmarks:
        landmarks = results.multi_face_landmarks[0].landmark

        # 提取唇部关键点像素坐标
        def get_pt(idx):
            return (int(landmarks[idx].x * w),
                    int(landmarks[idx].y * h))

        top = get_pt(LIP_TOP)
        bottom = get_pt(LIP_BOTTOM)
        left = get_pt(LIP_LEFT)
        right = get_pt(LIP_RIGHT)
        m_top = get_pt(MOUTH_TOP)
        m_bottom = get_pt(MOUTH_BOTTOM)

        # 计算嘴宽和嘴高
        mouth_width = np.linalg.norm(np.array(left) - np.array(right))
        mouth_height = np.linalg.norm(np.array(m_top) - np.array(m_bottom))
        ratio = mouth_height / mouth_width # 开合比（越高=嘴张越大）

        # 保存历史（最近 30 帧）
        mouth_ratio_history.append(ratio)
        if len(mouth_ratio_history) > 30:
            mouth_ratio_history.pop(0)

        # 判断是否在说话：开合度变化大 = 在说话
        if len(mouth_ratio_history) >= 10:
            ratio_std = np.std(mouth_ratio_history)
            is_speaking = ratio_std > SPEAKING_THRESHOLD
        else:
            is_speaking = False

        # 画图：嘴唇轮廓
        for idx in [LIP_TOP, LIP_BOTTOM, LIP_LEFT, LIP_RIGHT]:
            cv2.circle(frame, get_pt(idx), 3, (0, 255, 0), -1)

        # 画嘴部开合线
        cv2.line(frame, left, right, (255, 0, 0), 1)  # 嘴宽
        cv2.line(frame, m_top, m_bottom, (0, 0, 255), 2)  # 嘴高

        # 显示结果
        status = "SPEAKING" if is_speaking else "silent"
        color = (0, 0, 255) if is_speaking else (0, 255, 0)
        cv2.putText(frame, status, (10, 30),
                    cv2.FONT_HERSHEY_SIMPLEX, 1, color, 2)
        cv2.putText(frame, f'ratio: {ratio:.3f}', (10, 60),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 1)

    cv2.imshow('Lip Detection', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()