Tts302 (#170 )

* feat: add 302.ai TTS integration (#166) * update:将tts_302ai tts合并到doubao tts --------- Co-authored-by: Junsen <66542771+Huang-junsen@users.noreply.github.com> Co-authored-by: hrz <1710360675@qq.com>
音乐播放功能添加p3文件格式支持，添加文件目录(含子目录)扫描和文件列表刷新功能 (#157 )
2026-07-23 15:43:54 +08:00 · 2025-03-02 16:59:25 +08:00 · 2025-03-01 17:57:43 +08:00 · 2025-03-01 17:34:14 +08:00 · 2025-03-01 17:09:01 +08:00 · 2025-03-01 01:54:55 +08:00
20 changed files with 557 additions and 625 deletions
@@ -1,4 +1,15 @@
-![图片](docs/images/banner.png)
+[![SVG Banners](https://svg-banners.vercel.app/api?type=origin&text1=你好😃，小智📟&text2=开源小智ESP-32后端服务&width=830&height=210)](https://github.com/xinnan-tech/xiaozhi-esp32-server)
 <p align="center">
  <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/graphs/contributors">
    <img alt="GitHub Contributors" src="https://img.shields.io/github/contributors/xinnan-tech/xiaozhi-esp32-server" />
  </a>
  <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/issues">
    <img alt="Issues" src="https://img.shields.io/github/issues/xinnan-tech/xiaozhi-esp32-server?color=0088ff" />
  </a>
  <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/pulls">
    <img alt="GitHub pull requests" src="https://img.shields.io/github/issues-pr/xinnan-tech/xiaozhi-esp32-server?color=0088ff" />
  </a>
 </p>
 # 小智 ESP-32 后端服务(xiaozhi-esp32-server)
@@ -64,16 +75,23 @@
 - **硬件**：一套兼容 `xiaozhi-esp32`
  的硬件设备（具体型号请参考 [此处](https://rcnv1t9vps13.feishu.cn/wiki/DdgIw4BUgivWDPkhMj1cGIYCnRf)）。
- **服务器**：至少 4 核 CPU、8G 内存的电脑。
+
- **固件编译**：请将后端服务的接口地址更新至 `xiaozhi-esp32` 项目中，再重新编译固件并烧录到设备上。
+- **电脑或服务器**：至少 4 核 CPU、8G 内存的电脑。
 - **固件编译**：请将本后端服务的接口地址更新至 `xiaozhi-esp32` 项目中，再重新编译`xiaozhi-esp32`固件并烧录到设备上。
 如果你没有esp32相关的硬件设备，但是非常想体验该项目，可以使用以下的项目让你的电脑、手机模拟成esp32设备。
 - [小智安卓端](https://github.com/TOM88812/xiaozhi-android-client)
 - [小智电脑端](https://github.com/Huang-junsen/py-xiaozhi)
 ---
 ## 警告 ⚠️
-本项目成立时间较短，还未通过网络安全测评，请勿在生产环境中使用。
+1、本项目为开源软件，本软件与对接的任何第三方API服务商（包括但不限于语音识别、大模型、语音合成等平台）均不存在商业合作关系，不为其服务质量及资金安全提供任何形式的担保。
 建议使用者优先选择持有相关业务牌照的服务商，并仔细阅读其服务协议及隐私政策。本软件不托管任何账户密钥、不参与资金流转、不承担充值资金损失风险。
-如果您在公网环境中部署学习本项目，请务必在配置文件 `config.yaml` 中开启防护：
+2、本项目成立时间较短，还未通过网络安全测评，请勿在生产环境中使用。 如果您在公网环境中部署学习本项目，请务必在配置文件 `config.yaml` 中开启防护：
 ```yaml
 server:
@@ -165,7 +183,8 @@ server:
 本项目支持以下三种部署方式，您可根据实际需求选择。
-本项目的文档主要是`文字版本`的教程，如果你想要`视频版本`的教程，您可以学习一下[这个大佬的手把手教程](https://www.bilibili.com/video/BV1gePuejEvT)。
+本项目的文档主要是`文字版本`的教程，如果你想要`视频版本`
 的教程，您可以学习一下[这个大佬的手把手教程](https://www.bilibili.com/video/BV1gePuejEvT)。
 如果你能把`文字版本的教程`和`视频版本的教程`结合起来一起看，可以让你更快上手。
@@ -290,7 +309,13 @@ TTS 性能排行:
 ### 7、更多问题，可联系我们反馈 💬
-![图片](docs/images/wechat.jpg)
+我们的联系方式放在[百度网盘中,点击前往](https://pan.baidu.com/s/1x6USjvP1nTRsZ45XlJu65Q)，提取码是`223y`。
 网盘里有“硬件烧录QQ群”、“开源服务端交流群”、“产品建议联系人” 三张图片，请根据需要选择加入。
 - 硬件烧录QQ群：适用于硬件烧录问题
 - 开源服务端交流群：适用于服务端问题
 - 产品建议联系人：适用于产品功能、产品设计等建议
 ---
@@ -1,427 +1,291 @@
 ![图片](docs/images/banner.png)
-# Xiaozhi ESP-32 Back-end Service (xiaozhi-esp32-server)
+[![SVG Banners](https://svg-banners.vercel.app/api?type=origin&text1=Hello😃,%20XiaoZhi📟&text2=Open%20Source%20XiaoZhi%20ESP-32%20Backend%20Service&width=830&height=210)](https://github.com/xinnan-tech/xiaozhi-esp32-server)
 <p align="center">
  <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/graphs/contributors">
    <img alt="GitHub Contributors" src="https://img.shields.io/github/contributors/xinnan-tech/xiaozhi-esp32-server" />
  </a>
  <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/issues">
    <img alt="Issues" src="https://img.shields.io/github/issues/xinnan-tech/xiaozhi-esp32-server?color=0088ff" />
  </a>
  <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/pulls">
    <img alt="GitHub pull requests" src="https://img.shields.io/github/issues-pr/xinnan-tech/xiaozhi-esp32-server?color=0088ff" />
  </a>
 </p>
-（[中文](README.md) | English）
+# XiaoZhi ESP-32 Backend Service (xiaozhi-esp32-server)
-This project provides backend services for the open-source smart hardware
+([中文](README.md) | English)
 project [xiaozhi-esp32](https://github.com/78/xiaozhi-esp32)。Implemented in Python following
 the[Xiaozhi Communication Protocol](https://ccnphfhqs21z.feishu.cn/wiki/M0XiwldO9iJwHikpXD5cEx71nKh)。
-## Target Audience
+This project provides the backend service for the open source smart hardware project [xiaozhi-esp32](https://github.com/78/xiaozhi-esp32). It is implemented in `Python` based on the [XiaoZhi Communication Protocol](https://ccnphfhqs21z.feishu.cn/wiki/M0XiwldO9iJwHikpXD5cEx71nKh).
-This project requires compatible esp32 hardware devices. If you have purchased esp32 hardware, successfully connected to
+---
 Xiage's deployed backend, and wish to independently set up the `xiaozhi-esp32` backend service, this project is for
 you.
-To see a demo, watch this video:
+## Target Audience 👥
-<a href="https://www.bilibili.com/video/BV1FMFyejExX">
+This project is designed to be used in conjunction with ESP32 hardware devices. If you have already purchased an ESP32 device, successfully connected to the backend service deployed by XieGe, and now wish to set up your own `xiaozhi-esp32` backend service, then this project is perfect for you.
 <picture>
   <img alt="小智esp32连接自己的后台模型" src="docs/images/demo.png" />
 </picture>
 </a>
-To fully experience this project, follow these steps:
+Want to see it in action? Check out the videos 🎥
- Prepare hardware compatible with the `xiaozhi-esp32` project. For supported
+<table>
-  models, [click here](https://rcnv1t9vps13.feishu.cn/wiki/DdgIw4BUgivWDPkhMj1cGIYCnRf).
+  <tr>
- Use a computer/server with at least 4-core CPU and 8GB RAM to run this project. After deployment, you'll see the
+    <td>
-  service endpoint address in the console.
+      <a href="https://www.bilibili.com/video/BV1FMFyejExX" target="_blank">
- Download the `xiaozhi-esp32` project, replace the default `endpoint address` with your own, compile, and flash the
+        <picture>
-  firmware to your device.
+          <img alt="XiaoZhi ESP32 connecting to a custom backend model" src="docs/images/demo1.png" />
- Start the device and check your server console logs to verify successful connection.
+        </picture>
      </a>
    </td>
    <td>
      <a href="https://www.bilibili.com/video/BV1CDKWemEU6" target="_blank">
        <picture>
          <img alt="Custom Voice" src="docs/images/demo2.png" />
        </picture>
      </a>
    </td>
    <td>
      <a href="https://www.bilibili.com/video/BV12yA2egEaC" target="_blank">
        <picture>
          <img alt="Conversing in Cantonese" src="docs/images/demo3.png" />
        </picture>
      </a>
    </td>
    <td>
      <a href="https://www.bilibili.com/video/av114036381327149" target="_blank">
        <picture>
          <img alt="Control Home Appliances" src="docs/images/demo5.png" />
        </picture>
      </a>
    </td>
    <td>
      <a href="https://www.bilibili.com/video/BV1kgA2eYEQ9" target="_blank">
        <picture>
          <img alt="Lowest Cost Configuration" src="docs/images/demo4.png" />
        </picture>
      </a>
    </td>
    <td>
    </td>
  </tr>
 </table>
-## Warning
+---
-This project has been established for a short time and has not passed the network security assessment, so please do not
+## System Requirements and Deployment Prerequisites 🖥️
 use it in the production environment.
-## Feature List
+- **Hardware**: A set of devices compatible with `xiaozhi-esp32` (for specific models, please refer to [this link](https://rcnv1t9vps13.feishu.cn/wiki/DdgIw4BUgivWDPkhMj1cGIYCnRf)).
 - **Server**: A computer with at least a 4-core CPU and 8GB of memory.
 - **Firmware Compilation**: Please update the backend service API endpoint in the `xiaozhi-esp32` project, then recompile the firmware and flash it to your device.
-## Implemented
+---
- `xiaozhi-esp32` WebSocket communication protocol
+## Warning ⚠️
 - Supports wake-word initiated dialogue, manual dialogue, and real-time interruption of dialogue.
 - Support for 5 languages: Mandarin, Cantonese, English, Japanese, Korean (FunASR - default)
 - Flexible LLM switching (openai:ChatGLM - default, Aliyun, DeepSeek; dify:Dify)
 - Flexible TTS switching (EdgeTTS - default, ByteDance Doubao TTS)
-## In Progress
+This project is relatively new and has not yet undergone network security evaluations. **Do not use it in a production environment.**
- Sleep mode after inactivity
+If you deploy this project on a public network for learning purposes, be sure to enable protection in the configuration file `config.yaml`:
 - Dialogue memory
 - Change the mood mode
-## Supported Services
+```yaml
-
+server:
-| Type | Service    |  Usage   | Pricing Model	 | Notes                                                                      |
+  auth:
-|:-----|:-----------|:--------:|:---------------|:---------------------------------------------------------------------------|
+    # Enable protection
-| LLM  | Aliyun     | openai API call | Token-based    | [Apply for API Key](https://bailian.console.aliyun.com/?apiKey=1#/api-key) |
+    enabled: true  
 | LLM  | DeepSeek   | openai API call | Token-based    | [Apply for API Key](https://platform.deepseek.com/)                        |
 | LLM  | Bigmodel   | openai API call | Free           | [Create API Key](https://bigmodel.cn/usercenter/proj-mgmt/apikeys)         |
 | LLM  | Dify       | dify API call | Token-based    | Self-hosted                                                                |
 | TTS  | HuoshanTTS | API call | Token-based    | [Create API Key](https://console.volcengine.com/speech/service/8)          |
 | TTS  | EdgeTTS    | API call | Free           |                                                                            |
 | VAD  | SileroVAD  |  Local   | Free           |                                                                            |
 | ASR  | FunASR     |  Local   | Free           |                                                                            |
 In fact, any LLM that supports OpenAI API calls can be integrated and used.
 # Deployment
 This project supports rapid deployment of docker and local source code operation. If you want to have a quick
 experience, it is recommended to use docker to deploy. If you want to have an in-depth understanding of this project, it
 is recommended to run the local source code.
 ## Method 1: Quick deployment of docker
 The docker image has supported the CPU of x86 architecture and arm64 architecture, and supports running on Chinese
 operating systems.
 1. Install docker
 If your computer has not installed docker, you can follow the tutorial here to install
 it:[Install docker](https://www.runoob.com/docker/ubuntu-docker-install.html)
 2. Create a directory
 After installation, you need to find a directory for the configuration file for this project. Let's call it the
 `project directory` for the time being. This directory is preferably a newly created empty directory.
 3. Download the configuration file
 Open with a browser[This link](https://github.com/xinnan-tech/xiaozhi-esp32-server/blob/main/config.yaml)。
 On the right side of the page, find the button named `RAW`, next to the `RAW` button, find the download icon, click the
 Download button, and download the `config.yaml` file. Download the file to your `project directory`.
 4. Configure Project
 Modify the `config.yaml` file to configure the various parameters required for this project. The default LLM uses
 `ChatGLMLLM`, you need to configure the key to start.
 The default TTS uses `EdgeTTS`. This does not require configuration. If you need to replace it with`Doubao TTS`, you
 need to
 configure the key.
 Configuration description: This is the default component of each function, such as LLM default to use the `ChatGLMLLM`
 model. If you need to switch the model, it is the corresponding name.
 The default configuration of this project is only the lowest operating cost configuration（`glm-4-flash`and`EdgeTTS`are
 free），If you need to be better and faster, you need to combine the use of the deployment environment to switch the use
 of each component。
 ```
 selected_module:
  ASR: FunASR
  VAD: SileroVAD
  LLM: ChatGLMLLM
  TTS: EdgeTTS
 ```
-For example, to modify the components used by the `LLM`, it depends on which `LLM` API interfaces are supported by this project. Currently, the supported ones are `openai` and `dify`. We welcome validation and support for more LLM platforms' interfaces.
+Once protection is enabled, you will need to validate the machine's token or MAC address based on your actual situation. Please refer to the configuration documentation for details.
 When using it, change the `selected_module` to the corresponding name of the following LLM configurations:
 ```
 LLM:
  AliLLM:
    type: openai
    ...
  DeepSeekLLM:
    type: openai
    ...
  ChatGLMLLM:
    type: openai
    ...
  DifyLLM:
    type: openai
    ...
 ```
-Some services, for example, if you use the TTS` of the `dify` and` bean bags, you need a key, remember to add the
+---
 configuration file!
-5. Execute the docker command
+## Feature List ✨
 Open the command line tool, `cd` enter your `project directory`, and execute the following command
-```
+### Implemented ✅
 #If you are Linux, execute
 ls
 #If you are Windows, execute
 dir
 ```
-If you can see the `config.yaml` file, you have indeed entered the `project directory`, and then execute the following
+- **Communication Protocol**  
-command:
+  Based on the `xiaozhi-esp32` protocol, data exchange is implemented via WebSocket.
-
+- **Dialogue Interaction**  
-```
+  Supports wake-up dialogues, manual conversations, and real-time interruptions. Automatically enters sleep mode after long periods of inactivity.
-docker run -d --name xiaozhi-esp32-server --restart always --security-opt seccomp:unconfined -p 8000:8000 -v $(pwd)/config.yaml:/opt/xiaozhi-esp32-server/config.yaml ccr.ccs.tencentyun.com/xinnan/xiaozhi-esp32-server:latest
+- **Multilingual Recognition**  
-```
+  Supports Mandarin, Cantonese, English, Japanese, and Korean (default using FunASR).
-
+- **LLM Module**  
-If executed for the first time, it may take several minutes, and you have to be patient to wait for it to complete the
+  Allows flexible switching of LLM modules. The default is ChatGLMLLM, with options to use AliLLM, DeepSeek, Ollama, and others.
-pull. After normal pulling is completed, you can execute the following command on the command line to see if the service
+- **TTS Module**  
-is started successfully.
+  Supports multiple TTS interfaces including EdgeTTS (default) and Volcano Engine Doubao TTS to meet speech synthesis requirements.
 ```
 docker ps
 ```
 If you can see `xiaozhi-server`, it means that the service starts successfully. Then you can further execute the
 following command to view the service log
 ```
 docker logs -f xiaozhi-esp32-server
 ```
 If you can see, similar to the following logs, it is a sign that the service of this project is successfully launched.
 ```
 2025-xx-xx xx:51:59,492 - core.server - INFO - Server is running at ws://xx.xx.xx.xxx:8000
 2025-xx-xx xx:51:59,516 - websockets.server - INFO - server listening on 0.0.0.0:8000
 ```
 Next, you can start `compiling esp32 firmware`. Please go down and turn to the relevant chapter on
 `compiling esp32 firmware`. So since you are deploying with docker, you have to check the IP of your native computer by
 yourself.
 Normally, assuming your ip is `192.168.1.25`, then your interface address is: `ws://192.168.1.25:8000`. This information
 is very useful, and it is required to `compile esp32 firmware` later.
 ## Method 2 : Local Source Code Deployment
 ### 1.Install Prerequisites
 This project uses 'conda' to manage dependencies, and after installation, start executing the following commands:
 ```
 conda remove -n xiaozhi-esp32-server --all -y
 conda create -n xiaozhi-esp32-server python=3.10 -y
 conda activate xiaozhi-esp32-server
 ```
 After executing the above command, if your computer is Windows or Mac, execute the following statement:
 ```
 conda activate xiaozhi-esp32-server
 conda install conda-forge::libopus
 conda install conda-forge::ffmpeg
 ```
 If your computer is ubuntu, execute the following statement:
 ```
 apt-get install libopus0 ffmpeg 
 ```
 ### 2.Install Dependencies
 ```
 # Clone the project
 cd xiaozhi-esp32-server
 conda activate xiaozhi-esp32-server
 pip config set global.index-url https://mirrors.aliyun.com/pypi/simple/
 pip install -r requirements.txt
 ```
 ### 3.Download ASR Model
 Download [SenseVoiceSmall](https://modelscope.cn/models/iic/SenseVoiceSmall/resolve/master/model.pt) to
 `model/SenseVoiceSmall`.
 By default, the `SenseVoiceSmall` model is used to convert voice to text. Because the model is large, it needs to be
 downloaded independently. After downloading, place the `model.pt` file in the `model/SenseVoiceSmall` directory. Choose
 any of the following two download routes.
 - Line 1: Download Ali Magic
  Tower[SenseVoiceSmall](https://modelscope.cn/models/iic/SenseVoiceSmall/resolve/master/model.pt)
 - Line 2: Baidu Netdisk download[SenseVoiceSmall](https://pan.baidu.com/share/init?surl=QlgM58FHhYv1tFnUT_A8Sg&pwd=qvna)
  提取码: `qvna`
-### 4.Configure Project
+### In Development 🚧
 Modify the `config.yaml` file to configure the various parameters required for this project. The default LLM uses
 `ChatGLMLLM`, you need to configure the key to start.
 The default TTS uses `EdgeTTS`. This does not require configuration. If you need to replace it with`Doubao TTS`, you
 need to
 configure the key.
 Configuration description: This is the default component of each function, such as LLM default to use the `ChatGLMLLM`
 model. If you need to switch the model, it is the corresponding name.
 The default configuration of this project is only the lowest operating cost configuration（`glm-4-flash`and`EdgeTTS`are
 free），If you need to be better and faster, you need to combine the use of the deployment environment to switch the use
 of each component。
-```
+- Conversation Memory Feature
-selected_module:
+- Multiple Mood Modes
-  ASR: FunASR
+- Smart Control Panel Web UI
  VAD: SileroVAD
  LLM: ChatGLMLLM
  TTS: EdgeTTS
 ```
 For example, to modify the components used by the `LLM`, it depends on which `LLM` API interfaces are supported by this project. Currently, the supported ones are `openai` and `dify`. We welcome validation and support for more LLM platforms' interfaces.
 When using it, change the `selected_module` to the corresponding name of the following LLM configurations:
 ```
 LLM:
  AliLLM:
    type: openai
    ...
  DeepSeekLLM:
    type: openai
    ...
  ChatGLMLLM:
    type: openai
    ...
  DifyLLM:
    type: openai
    ...
 ```
 Some services, for example, if you use the TTS` of the `dify` and` bean bags, you need a key, remember to add the
 configuration file!
 ### 5.Run the Project
-Run the Project
+![Screenshot](docs/images/webui.png)
-```
+---
 # Make sure to execute in the root directory of this project
 conda activate xiaozhi-esp32-server
 python app.py
 ```
-You'll see the WebSocket endpoint in logs:
+## Supported Platforms/Components 📋
-```
+### LLM
 2025-xx-xx xx:51:59,492 - core.server - INFO - Server is running at ws://192.168.1.25:8000
 2025-xx-xx xx:51:59,516 - websockets.server - INFO - server listening on 0.0.0.0:8000
 ```
-Among them, the `ws://192.168.1.25:8000` is the interface address provided by this project. Of course, your own machine
+| Type |         Platform Name         |         Usage Method          |   Pricing Model   |                                 Remarks                                  |
-is different from mine. Remember to find your own address.
+|:----:|:-----------------------------:|:-----------------------------:|:-----------------:|:-------------------------------------------------------------------------:|
 | LLM  |   AliLLM (阿里百炼)           | OpenAI API call               | Token consumption | [Click to apply for API key](https://bailian.console.aliyun.com/?apiKey=1#/api-key) |
 | LLM  | DeepSeekLLM (深度求索)        | OpenAI API call               | Token consumption |          [Click to apply for API key](https://platform.deepseek.com/)         |
 | LLM  | ChatGLMLLM (智谱)             | OpenAI API call               | Free              | Although free, you still need to [click to apply for an API key](https://bigmodel.cn/usercenter/proj-mgmt/apikeys) |
 | LLM  | OllamaLLM                   | Ollama API call               | Free/Custom       | Requires pre-downloading the model (`ollama pull`); service URL: `http://localhost:11434` |
 | LLM  | DifyLLM                     | Dify API call                 | Token consumption | For local deployment. Note that prompt configuration must be set in the Dify console. |
 | LLM  | GeminiLLM                   | Gemini API call               | Free              | [Click to apply for API key](https://aistudio.google.com/apikey) |
 | LLM  | CozeLLM                     | Coze API call                 | Token consumption | Requires providing bot_id, user_id, and personal token. |
 | LLM  | Home Assistant              | Home Assistant voice assistant API call | Free       | Requires providing a Home Assistant token. |
-# Compile ESP32 Firmware
+In fact, any LLM that supports OpenAI API calls can be integrated.
-1. Download `xiaozhi-esp32` project, configure the project environment according to this
+---
   tutorial [" Windows builds ESP IDF 5.3.2 Development Environment and Compiles Xiaozhi "](https://icnynnzcwou8.feishu.cn/wiki/JEYDwTTALi5s2zkGlFGcDiRknXf)
   Cure
-2. Open the `xiaozhi-esp32/main/kconfig.projbuild` file, find the content of the` websocket_url` `default`, change the
+### TTS
   ` wss: // api.tenclass.net` to your own address, such as
-Before modification:
+| Type |             Platform Name              | Usage Method |   Pricing Model   |                                       Remarks                                        |
 |:----:|:--------------------------------------:|:------------:|:-----------------:|:--------------------------------------------------------------------------------------:|
 | TTS  |               EdgeTTS                  | API call     | Free              | Default TTS based on Microsoft's speech synthesis technology.                        |
 | TTS  | DoubaoTTS (火山引擎豆包 TTS)             | API call     | Token consumption | [Click to create an API key](https://console.volcengine.com/speech/service/8); it is recommended to use the paid version for higher concurrency. |
 | TTS  | CosyVoiceSiliconflow                   | API call     | Token consumption | Requires application for the Siliconflow API key; output format is WAV.                |
 | TTS  | CozeCnTTS                              | API call     | Token consumption | Requires providing a Coze API key; output format is WAV.                               |
 | TTS  | FishSpeech                             | API call     | Free/Custom       | Starts a local TTS service; see the configuration file for startup instructions.       |
 | TTS  | GPT_SOVITS_V2                          | API call     | Free/Custom       | Starts a local TTS service, suitable for personalized speech synthesis scenarios.      |
-```
+---
 config WEBSOCKET_URL
    depends on CONNECTION_TYPE_WEBSOCKET
    string "Websocket URL"
    default "wss://api.tenclass.net/xiaozhi/v1/"
    help
        Communication with the server through websocket after wake up.
 ```
-After modification (example):
+### VAD
-```
+| Type |    Platform Name    | Usage Method | Pricing Model | Remarks |
-config WEBSOCKET_URL
+|:----:|:-------------------:|:------------:|:-------------:|:-------:|
-    depends on CONNECTION_TYPE_WEBSOCKET
+| VAD  | SileroVAD           | Local        | Free          |         |
    string "Websocket URL"
    default "ws://192.168.1.25:8000/xiaozhi/v1/"
    help
        Communication with the server through websocket after wake up.
 ```
-3. Configure build settings:
+---
-```
+### ASR
 # The terminal command line enters the root directory of xiaozhi-esp32
 cd xiaozhi-esp32
 # For example, the board I use is ESP32S3, so the compile target is ESP32S3. If your board is other models, please replace it with the corresponding model
 idf.py set-target esp32s3
 # Enter the menu configuration
 idf.py menuconfig
 ```
-![图片](docs/images/build_setting01.png)
+| Type |    Platform Name    | Usage Method | Pricing Model | Remarks |
 |:----:|:-------------------:|:------------:|:-------------:|:-------:|
 | ASR  | FunASR              | Local        | Free          |         |
 | ASR  | DoubaoASR           | API call     | Paid          |         |
-After entering the menu configuration, then enter `xiaozhi assistant`, set the` connection_type` to `websocket`
+---
 Go back to the main menu, then enter `xiaozhi assistant`, set the `BOARD_TYPE` of your board
 Save exit and return to the terminal command line.
-![图片](docs/images/build_setting02.png)
+## Usage 🚀
-4. Build and package:
+### 1. [Deployment Documentation](./docs/Deployment.md)
-```
+This project supports three deployment methods. Choose the one that best fits your needs.
 idf.py build
 cd scripts
 python release.py
 ```
-After the compilation is successful, the firmware file `merged-binary.bin` is generated in the` build` directory in the
+The documentation provided here is a **written tutorial**. If you prefer a **video tutorial**, you can refer to [this expert's hands-on guide](https://www.bilibili.com/video/BV1gePuejEvT).
 project root directory.
 This `merged-binary.bin` is the firmware file that will be recorded on the hardware.
-6. Flash
+Combining both the written and video tutorials can help you get started more quickly.
   Connect the ESP32 device to the computer, use the Chrome browser, and open the following URL
-```
+1. [Docker Quick Deployment](./docs/Deployment.md)  
-https://espressif.github.io/esp-launchpad/
+   Suitable for general users who want a quick experience without extensive environment configuration. The only downside is that pulling the image can be a bit slow.
 ```
-Open this
+2. [Deployment Using Docker Environment](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%BA%8C%E5%80%9F%E5%8A%A9docker%E7%8E%AF%E5%A2%83%E8%BF%90%E8%A1%8C%E9%83%A8%E7%BD%B2)  
-tutorial, [Flash Tools/Web -side Burning Folding Step (No IDF Development Environment)](https://ccnphfhqs21z.feishu.cn/wiki/Zpz4wXBtdimBrLk25WdcXzxcnNS).
+   Ideal for software engineers who already have Docker installed and wish to customize the code.
 Turn to: `Method 2: ESP-LAUNCHPAD browser web-end burning`, start from
 `3. Burning firmware/download to the development board`, follow the tutorial operation.
-# FAQ
+3. [Running from Local Source Code](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%B8%89%E6%9C%AC%E5%9C%B0%E6%BA%90%E7%A0%81%E8%BF%90%E8%A1%8C)  
   Suitable for users familiar with the `Conda` environment or those who wish to build the runtime environment from scratch.
-## 1、TTS often fails, often overtime
+For scenarios requiring higher response speeds, running from the local source code is recommended to reduce additional overhead.
-Suggestion: If the `Edgetts` is slow or often fails, you can replace it with a bean bag TTS` with a volcanic engine. If
+### 2. [Firmware Compilation](./docs/firmware-build.md)
 both are slow, the network environment may need to be optimized.
-## 2、Big model reply is a bit slow
+Click [here](./docs/firmware-build.md) for a detailed guide on firmware compilation.
-Suggestions: Both big models and TTS are dependent interfaces. If the network environment is not good, you can consider
+After successful compilation and network connection, wake up XiaoZhi using the wake-up word and monitor the server console for output.
 changing the local model. Or try to switch different interface models.
-## 3、Why is my ChatGLMLLM replying to a bit? Obviously it is Xiaozhi, but treats me as Xiaozhi.
+---
-Suggestion: You can modify the prompts in the configuration file first. You can also replace the free `GLM-4-FLASH` to
+## Frequently Asked Questions ❓
 the model of other toll versions of `ChatGlm`.
-## 4、I want to control the operation of electric lights, air conditioners, remote switching and other operations through Xiaozhi.
+### 1. TTS often fails and times out ⏰
-Suggestion: In the configuration file, set the `LLM` to`DifyLLM`, and then arrange the smart application by the
+**Suggestion:**  
-`Dify`.
+If `EdgeTTS` frequently fails, please first check whether you are using a proxy (VPN). If so, try disabling the proxy and try again. If you are using Volcano Engine Doubao TTS and it often fails, it is recommended to use the paid version since the trial only supports 2 concurrent requests.
-## 5、I said very slowly, I paused, Xiaozhi always grabbed me, what to do.
+### 2. I want to control lights, air conditioners, remote power on/off, etc. with XiaoZhi 💡
-Suggestion: In the configuration file, find this section, change the `min_silence_duration_ms` value, such as change to
+**Suggestion:**  
-` 1000`.
+Set the `LLM` to `HomeAssistant` in the configuration file and use the `HomeAssistant` API to perform the relevant controls.
-```
+### 3. I speak slowly, and XiaoZhi always interrupts during pauses 🗣️
 **Suggestion:**  
 Locate the following section in the configuration file and increase the value of `min_silence_duration_ms` (for example, change it to `1000`):
 ```yaml
 VAD:
  SileroVAD:
    threshold: 0.5
    model_dir: models/snakers4_silero-vad
-    min_silence_duration_ms: 700  # 如果说话停顿比较长，可以把这个值设置大一些
+    min_silence_duration_ms: 700  # If your pauses are longer, increase this value
 ```
-## 6、For more questions, contact us to feedback
+### 4. Why does XiaoZhi recognize a lot of Korean, Japanese, and English in what I say? 🇰🇷
-![图片](docs/images/wechat.jpg)
+**Suggestion:**  
 Check whether the `model.pt` file exists in the `models/SenseVoiceSmall` directory. If it does not, please download it. See [Download ASR Model Files](docs/Deployment.md#模型文件) for details.
-# Acknowledgments
+### 5. Why does the error “TTS task error: file does not exist” occur? 📁
- This project is inspired by the [Bailin Voice Dialogue Robot](https://github.com/wwbin2017/bailing) project, and the
+**Suggestion:**  
-  basic idea of the project is completed。
+Verify that you have correctly installed the `libopus` and `ffmpeg` libraries using `conda`. If not, install them using:
- Thanks to [Tencent Cloud] (https://cloud.tencent.com/) for providing free docker space for this project。
+
- Thanks to [tenclass](https://www.tenclass.com/)Provide adequate documentation support on Xiaozhi Communication
+```
-  Protocol。
+conda install conda-forge::libopus
 conda install conda-forge::ffmpeg
 ```
 ### 6. How can I improve XiaoZhi's dialogue response speed? ⚡
 The default configuration of this project is designed to be cost-effective. It is recommended that beginners first use the default free models to ensure that the system runs smoothly, then optimize for faster response times.  
 To improve response speed, you can try replacing individual components. Below are the response time test results for each component (for reference only, not a guarantee):
 **LLM Performance Ranking:**
 | Module Name  | Average First Token Time | Average Total Response Time |
 |--------------|--------------------------|-----------------------------|
 | AliLLM       | 0.547s                   | 1.485s                      |
 | ChatGLMLLM   | 0.677s                   | 3.057s                      |
 | OllamaLLM    | 0.003s                   | 0.003s                      |
 **TTS Performance Ranking:**
 | Module Name                | Average Synthesis Time |
 |----------------------------|------------------------|
 | EdgeTTS                    | 1.019s                 |
 | DoubaoTTS                  | 0.503s                 |
 | CosyVoiceSiliconflow       | 3.732s                 |
 **Recommended Configuration Combination (Overall Response Speed):**
 | Combination Scheme                | Overall Score | LLM First Token | TTS Synthesis |
 |-----------------------------------|---------------|-----------------|---------------|
 | AliLLM + DoubaoTTS                | 0.539         | 0.547s          | 0.503s        |
 | AliLLM + EdgeTTS                  | 0.642         | 0.547s          | 1.019s        |
 | ChatGLMLLM + DoubaoTTS            | 0.642         | 0.677s          | 0.503s        |
 | ChatGLMLLM + EdgeTTS              | 0.745         | 0.677s          | 1.019s        |
 | AliLLM + CosyVoiceSiliconflow     | 1.184         | 0.547s          | 3.732s        |
 **Conclusion 🔍**
 _As of February 19, 2025, if my computer were located in Haizhu District, Guangzhou, Guangdong Province, and connected via China Unicom, I would prioritize using:_
 - **LLM:** `AliLLM`
 - **TTS:** `DoubaoTTS`
 ### 7. For more questions, feel free to contact us for feedback 💬
 Our contact information is in [Baidu Netdisk](https://pan.baidu.com/s/1x6USjvP1nTRsZ45XlJu65Q)，The extraction code is`223y`。
 ---
 ## Acknowledgements 🙏
 - This project was inspired by the [Bailing Voice Dialogue Robot](https://github.com/wwbin2017/bailing) and implemented based on it.
 - Many thanks to [Tenclass](https://www.tenclass.com/) for providing detailed documentation support for the XiaoZhi communication protocol.
 <a href="https://star-history.com/#xinnan-tech/xiaozhi-esp32-server&Date">
 <picture>
@@ -1,17 +1,20 @@
 import asyncio
 from config.logger import setup_logging
-from config.settings import load_config
+from config.settings import load_config, check_config_file
 from core.websocket_server import WebSocketServer
 from manager.http_server import WebUI
 from aiohttp import web
-from core.utils.util import get_local_ip
+from core.utils.util import get_local_ip, check_ffmpeg_installed
 TAG = __name__
 async def main():
    check_config_file()
    check_ffmpeg_installed()
    logger = setup_logging()
    config = load_config()
-    
+
    # 启动 WebSocket 服务器
    ws_server = WebSocketServer(config)
    ws_task = asyncio.create_task(ws_server.start())
@@ -33,7 +36,7 @@ async def main():
            logger.bind(tag=TAG).info(f"WebUI server is running at http://{local_ip}:{port}")
        except Exception as e:
            logger.bind(tag=TAG).error(f"Failed to start WebUI server: {e}")
-    
+
    try:
        # 等待 WebSocket 服务器运行
        await ws_task
@@ -42,5 +45,6 @@ async def main():
        if webui_runner:
            await webui_runner.cleanup()
 if __name__ == "__main__":
    asyncio.run(main())
@@ -175,8 +175,10 @@ TTS:
    # 山引擎语音一定要购买花钱，起步价30元，就有100并发了。如果用免费的只有2个并发，会经常报tts错误
    # 购买服务后，购买免费的音色后，可能要等半小时左右，才能使用。
    # 地址：https://console.volcengine.com/speech/service/8
    api_url: https://openspeech.bytedance.com/api/v1/tts
    voice: BV001_streaming
    output_file: tmp/
    authorization: "Bearer;"
    appid: 你的火山引擎语音合成服务appid
    access_token: 你的火山引擎语音合成服务access_token
    cluster: volcano_tts
@@ -305,7 +307,18 @@ TTS:
    # volume: 50
    # speech_rate: 0
    # pitch_rate: 0
-
+    # 添加 302.ai TTS 配置
    # token申请地址：https://dash.302.ai/
  TTS302AI:
    # 302AI语音合成服务，需要先在302平台创建账户充值，并获取密钥信息
    # 获取api_keyn路径：https://dash.302.ai/apis/list
    # 价格，$35/百万字符。火山原版¥450元/万字符
    type: doubao
    api_url: https://api.302ai.cn/doubao/tts_hd
    authorization: "Bearer "
    voice: "zh_female_wanwanxiaohe_moon_bigtts"
    output_file: tmp/
    access_token: "你的302API密钥"
 # 模块测试配置
 module_test:
  test_sentences:  # 自定义测试语句
@@ -327,4 +340,9 @@ music:
    - "我想听歌"
    - "我要听歌"
    - "放点音乐"
-  music_dir: "./music"  # 音乐文件存放路径
+  music_dir: "./music"  # 音乐文件存放路径，将从该目录及子目录下搜索音乐文件
  music_ext: # 音乐文件类型，p3格式效率最高
    - ".mp3"
    - ".wav"
    - ".p3"
  refresh_time: 300 # 刷新音乐列表的时间间隔，单位为秒
@@ -1,22 +1,26 @@
 import os
 import argparse
 from ruamel.yaml import YAML
 from collections.abc import Mapping
 from core.utils.util import read_config, get_project_dir
 default_config_file = "config.yaml"
 def get_config_file():
-    default_config_file = "config.yaml"
+    global default_config_file
    # 判断是否存在私有的配置文件
    config_file = default_config_file
    if os.path.exists(get_project_dir() + "data/." + default_config_file):
-        default_config_file = "data/." + default_config_file
+        config_file = "data/." + default_config_file
-    return default_config_file
+    return config_file
 def load_config():
    """加载配置文件"""
    parser = argparse.ArgumentParser(description="Server configuration")
-    default_config_file = get_config_file()
+    config_file = get_config_file()
-    parser.add_argument("--config_path", type=str, default=default_config_file)
+    parser.add_argument("--config_path", type=str, default=config_file)
    args = parser.parse_args()
    return read_config(args.config_path)
@@ -27,3 +31,54 @@ def update_config(config):
    """将配置保存到YAML文件"""
    with open(get_config_file(), 'w') as f:
        yaml.dump(config, f)
 def find_missing_keys(new_config, old_config, parent_key=''):
    """
    递归查找缺失的配置项
    返回格式：[缺失配置路径]
    """
    missing_keys = []
    if not isinstance(new_config, Mapping):
        return missing_keys
    for key, value in new_config.items():
        # 构建当前配置路径
        full_path = f"{parent_key}.{key}" if parent_key else key
        # 检查键是否存在
        if key not in old_config:
            missing_keys.append(full_path)
            continue
        # 递归检查嵌套字典
        if isinstance(value, Mapping):
            sub_missing = find_missing_keys(
                value,
                old_config[key],
                parent_key=full_path
            )
            missing_keys.extend(sub_missing)
    return missing_keys
 def check_config_file():
    old_config_file = get_config_file()
    global default_config_file
    if not old_config_file.startswith('data'):
        return
    old_config = read_config(get_project_dir() + old_config_file)
    new_config = read_config(get_project_dir() + default_config_file)
    # 查找缺失的配置项
    missing_keys = find_missing_keys(new_config, old_config)
    if missing_keys:
        error_msg = "您的配置文件太旧了，缺少了：\n"
        error_msg += "\n".join(f"- {key}" for key in missing_keys)
        error_msg += "\n建议您：\n"
        error_msg += "1、备份data/.config.yaml文件\n"
        error_msg += "2、将根目录的config.yaml文件复制到data下，重命名为.config.yaml\n"
        error_msg += "3、将密钥逐个复制到新的配置文件中\n"
        raise ValueError(error_msg)
@@ -9,8 +9,6 @@ from config.logger import setup_logging
 import threading
 import websockets
 from typing import Dict, Any
 from collections import deque
 from core.utils.util import is_segment
 from core.utils.dialogue import Message, Dialogue
 from core.handle.textHandle import handleTextMessage
 from core.utils.util import get_string_no_punctuation_or_emoji
@@ -21,7 +19,6 @@ from config.private_config import PrivateConfig
 from core.auth import AuthMiddleware, AuthenticationError
 from core.utils.auth_code_gen import AuthCodeGenerator
 TAG = __name__
@@ -45,8 +42,8 @@ class ConnectionHandler:
        self.loop = asyncio.get_event_loop()
        self.stop_event = threading.Event()
        self.tts_queue = queue.Queue()
        self.audio_play_queue = queue.Queue()
        self.executor = ThreadPoolExecutor(max_workers=10)
        self.scheduled_tasks = deque()
        # 依赖的组件
        self.vad = _vad
@@ -140,9 +137,14 @@ class ConnectionHandler:
            await self.loop.run_in_executor(None, self._initialize_components)
-            tts_priority = threading.Thread(target=self._priority_thread, daemon=True)
+            # tts 消化线程
            tts_priority = threading.Thread(target=self._tts_priority_thread, daemon=True)
            tts_priority.start()
            # 音频播放 消化线程
            audio_play_priority = threading.Thread(target=self._audio_play_priority_thread, daemon=True)
            audio_play_priority.start()
            try:
                async for message in self.websocket:
                    await self._route_message(message)
@@ -198,10 +200,8 @@ class ConnectionHandler:
        return not self.is_device_verified
    def chat(self, query):
        # 如果设备未验证，就发送验证码
        if self.isNeedAuth():
            self.llm_finish_task = True
            # 创建一个新的事件循环来运行异步函数
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)
            try:
@@ -212,49 +212,61 @@ class ConnectionHandler:
        self.dialogue.put(Message(role="user", content=query))
        response_message = []
-        start = 0
+        processed_chars = 0  # 跟踪已处理的字符位置
        # 提交 LLM 任务
        try:
-            start_time = time.time()  # 记录开始时间
+            start_time = time.time()
            llm_responses = self.llm.response(self.session_id, self.dialogue.get_llm_dialogue())
        except Exception as e:
            self.logger.bind(tag=TAG).error(f"LLM 处理出错 {query}: {e}")
            return None
-        # 提交 TTS 任务到线程池
+
        self.llm_finish_task = False
        for content in llm_responses:
            response_message.append(content)
            # 如果中途被打断，就停止生成
            if self.client_abort:
                start = len(response_message)
                break
-            end_time = time.time()  # 记录结束时间
+            end_time = time.time()
-            self.logger.bind(tag=TAG).debug(f"大模型返回时间时间: {end_time - start_time} 秒, 生成token={content}")
+            self.logger.bind(tag=TAG).debug(f"大模型返回时间: {end_time - start_time} 秒, 生成token={content}")
-            if is_segment(response_message):
+
-                segment_text = "".join(response_message[start:])
+            # 合并当前全部文本并处理未分割部分
-                segment_text = get_string_no_punctuation_or_emoji(segment_text)
+            full_text = "".join(response_message)
-                if len(segment_text) > 0:
+            current_text = full_text[processed_chars:]  # 从未处理的位置开始
            # 查找最后一个有效标点
            punctuations = ("。", "？", "！", "?", "!", ";", "；", ":", "：", "，")
            last_punct_pos = -1
            for punct in punctuations:
                pos = current_text.rfind(punct)
                if pos > last_punct_pos:
                    last_punct_pos = pos
            # 找到分割点则处理
            if last_punct_pos != -1:
                segment_text_raw = current_text[:last_punct_pos + 1]
                segment_text = get_string_no_punctuation_or_emoji(segment_text_raw)
                if segment_text:
                    self.recode_first_last_text(segment_text)
                    future = self.executor.submit(self.speak_and_play, segment_text)
                    self.tts_queue.put(future)
-                    start = len(response_message)
+                    processed_chars += len(segment_text_raw)  # 更新已处理字符位置
-        # 处理剩余的响应
+        # 处理最后剩余的文本
-        if start < len(response_message):
+        full_text = "".join(response_message)
-            segment_text = "".join(response_message[start:])
+        remaining_text = full_text[processed_chars:]
-            if len(segment_text) > 0:
+        if remaining_text:
            segment_text = get_string_no_punctuation_or_emoji(remaining_text)
            if segment_text:
                self.recode_first_last_text(segment_text)
                future = self.executor.submit(self.speak_and_play, segment_text)
                self.tts_queue.put(future)
        self.llm_finish_task = True
        # 更新对话
        self.dialogue.put(Message(role="assistant", content="".join(response_message)))
        self.logger.bind(tag=TAG).debug(json.dumps(self.dialogue.get_llm_dialogue(), indent=4, ensure_ascii=False))
        return True
-    def _priority_thread(self):
+    def _tts_priority_thread(self):
        while not self.stop_event.is_set():
            text = None
            try:
@@ -276,7 +288,6 @@ class ConnectionHandler:
                    else:
                        self.logger.bind(tag=TAG).error(f"TTS文件不存在: {tts_file}")
                        opus_datas = []
                        duration = 0
                except TimeoutError:
                    self.logger.bind(tag=TAG).error("TTS 任务超时")
                    continue
@@ -285,9 +296,7 @@ class ConnectionHandler:
                    continue
                if not self.client_abort:
                    # 如果没有中途打断就发送语音
-                    asyncio.run_coroutine_threadsafe(
+                    self.audio_play_queue.put((opus_datas, text))
                        sendAudioMessage(self, opus_datas, duration, text), self.loop
                    )
                if self.tts.delete_audio_file and os.path.exists(tts_file):
                    os.remove(tts_file)
            except Exception as e:
@@ -299,6 +308,16 @@ class ConnectionHandler:
                )
                self.logger.bind(tag=TAG).error(f"tts_priority priority_thread: {text}{e}")
    def _audio_play_priority_thread(self):
        while not self.stop_event.is_set():
            text = None
            try:
                opus_datas, text = self.audio_play_queue.get()
                future = asyncio.run_coroutine_threadsafe(sendAudioMessage(self, opus_datas, text), self.loop)
                future.result()
            except Exception as e:
                self.logger.bind(tag=TAG).error(f"audio_play_priority priority_thread: {text}{e}")
    def speak_and_play(self, text):
        if text is None or len(text) <= 0:
            self.logger.bind(tag=TAG).info(f"无需tts转换，query为空，{text}")
@@ -340,9 +359,3 @@ class ConnectionHandler:
        self.client_have_voice_last_time = 0
        self.client_voice_stop = False
        self.logger.bind(tag=TAG).debug("VAD states reset.")
    def stop_all_tasks(self):
        while self.scheduled_tasks:
            task = self.scheduled_tasks.popleft()
            task.cancel()
        self.scheduled_tasks.clear()
@@ -1,4 +1,5 @@
 import json
 import queue
 from config.logger import setup_logging
 TAG = __name__
@@ -9,8 +10,6 @@ async def handleAbortMessage(conn):
    logger.bind(tag=TAG).info("Abort message received")
    # 设置成打断状态，会自动打断llm、tts任务
    conn.client_abort = True
    # 打断屏显任务
    conn.stop_all_tasks()
    # 打断客户端说话状态
    await conn.websocket.send(json.dumps({"type": "tts", "state": "stop", "session_id": conn.session_id}))
    conn.clearSpeakStatus()
@@ -4,7 +4,10 @@ import random
 import difflib
 import re
 import traceback
-from core.handle.sendAudioHandle import sendAudioMessage, send_stt_message
+from pathlib import Path
 import time
 from core.handle.sendAudioHandle import send_stt_message
 from core.utils import p3
 TAG = __name__
 logger = setup_logging()
@@ -33,6 +36,24 @@ def _find_best_match(potential_song, music_files):
            best_match = music_file
    return best_match
 class MusicManager:
    def __init__(self, music_dir, music_ext):
        self.music_dir = Path(music_dir)
        self.music_ext = music_ext
    def get_music_files(self):
        music_files = []
        for file in self.music_dir.rglob("*"):
            # 判断是否是文件
            if file.is_file():
                # 获取文件扩展名
                ext = file.suffix.lower()
                # 判断扩展名是否在列表中
                if ext in self.music_ext:
                    # music_files.append(str(file.resolve()))  # 添加绝对路径
                    # 添加相对路径
                    music_files.append(str(file.relative_to(self.music_dir)))
        return music_files
 class MusicHandler:
    def __init__(self, config):
@@ -45,10 +66,19 @@ class MusicHandler:
                self.music_config.get("music_dir", "./music")  # 默认路径修改
            )
            self.music_related_keywords = self.music_config.get("music_commands", [])
            self.music_ext = self.music_config.get("music_ext", (".mp3", ".wav", ".p3"))
            self.refresh_time = self.music_config.get("refresh_time", 60)
        else:
            self.music_dir = os.path.abspath("./music")
            self.music_related_keywords = ["来一首歌", "唱一首歌", "播放音乐", "来点音乐", "背景音乐", "放首歌",
                                           "播放歌曲", "来点背景音乐", "我想听歌", "我要听歌", "放点音乐"]
            self.music_ext = (".mp3", ".wav", ".p3")
            self.refresh_time = 60
        # 获取音乐文件列表
        self.music_files = MusicManager(self.music_dir, self.music_ext).get_music_files()
        self.scan_time = time.time()
        logger.bind(tag=TAG).debug(f"找到的音乐文件: {self.music_files}")
    async def handle_music_command(self, conn, text):
        """处理音乐播放指令"""
@@ -57,12 +87,15 @@ class MusicHandler:
        # 尝试匹配具体歌名
        if os.path.exists(self.music_dir):
-            music_files = [f for f in os.listdir(self.music_dir) if f.endswith('.mp3')]
+            if time.time() - self.scan_time > self.refresh_time:
-            logger.bind(tag=TAG).debug(f"找到的音乐文件: {music_files}")
+                # 刷新音乐文件列表
                self.music_files = MusicManager(self.music_dir, self.music_ext).get_music_files()
                self.scan_time = time.time()
                logger.bind(tag=TAG).debug(f"刷新的音乐文件: {self.music_files}")
            potential_song = _extract_song_name(clean_text)
            if potential_song:
-                best_match = _find_best_match(potential_song, music_files)
+                best_match = _find_best_match(potential_song, self.music_files)
                if best_match:
                    logger.bind(tag=TAG).info(f"找到最匹配的歌曲: {best_match}")
                    await self.play_local_music(conn, specific_file=best_match)
@@ -90,19 +123,30 @@ class MusicHandler:
                    return
                selected_music = specific_file
            else:
-                music_files = [f for f in os.listdir(self.music_dir) if f.endswith('.mp3')]
+                if time.time() - self.scan_time > self.refresh_time:
-                if not music_files:
+                    # 刷新音乐文件列表
                    self.music_files = MusicManager(self.music_dir, self.music_ext).get_music_files()
                    self.scan_time = time.time()
                    logger.bind(tag=TAG).debug(f"刷新的音乐文件列表: {self.music_files}")
                if not self.music_files:
                    logger.bind(tag=TAG).error("未找到MP3音乐文件")
                    return
-                selected_music = random.choice(music_files)
+                selected_music = random.choice(self.music_files)
                music_path = os.path.join(self.music_dir, selected_music)
                if not os.path.exists(music_path):
                    logger.bind(tag=TAG).error(f"选定的音乐文件不存在: {music_path}")
                    return
            text = f"正在播放{selected_music}"
            await send_stt_message(conn, text)
            conn.tts_first_text = selected_music
            conn.tts_last_text = selected_music
            conn.llm_finish_task = True
-            opus_packets, duration = conn.tts.wav_to_opus_data(music_path)
+            if music_path.endswith(".p3"):
-            await sendAudioMessage(conn, opus_packets, duration, selected_music)
+                opus_packets, duration = p3.decode_opus_from_file(music_path)
            else:
                opus_packets, duration = conn.tts.wav_to_opus_data(music_path)
            conn.audio_play_queue.put((opus_packets, selected_music))
        except Exception as e:
            logger.bind(tag=TAG).error(f"播放音乐失败: {str(e)}")
@@ -1,8 +1,7 @@
 from config.logger import setup_logging
 import asyncio
 import time
 from core.utils.util import remove_punctuation_and_length
-from core.handle.sendAudioHandle import schedule_with_interrupt, send_stt_message
+from core.handle.sendAudioHandle import send_stt_message
 TAG = __name__
 logger = setup_logging()
@@ -61,10 +60,7 @@ async def handleCMDMessage(conn, text):
 async def startToChat(conn, text):
    # 异步发送 stt 信息
-    stt_task = asyncio.create_task(
+    await send_stt_message(conn, text)
        schedule_with_interrupt(0, send_stt_message(conn, text))
    )
    conn.scheduled_tasks.append(stt_task)
    conn.executor.submit(conn.chat, text)
@@ -8,49 +8,47 @@ TAG = __name__
 logger = setup_logging()
-async def isLLMWantToFinish(conn):
+async def isLLMWantToFinish(last_text):
    first_text = conn.tts_first_text
    last_text = conn.tts_last_text
    _, last_text_without_punctuation = remove_punctuation_and_length(last_text)
    if "再见" in last_text_without_punctuation or "拜拜" in last_text_without_punctuation:
        return True
    _, first_text_without_punctuation = remove_punctuation_and_length(first_text)
    if "再见" in first_text_without_punctuation or "拜拜" in first_text_without_punctuation:
        return True
    return False
-async def sendAudioMessage(conn, audios, duration, text):
+async def sendAudioMessage(conn, audios, text):
-    base_delay = conn.tts_duration
+    # 发送句子开始消息
    # 发送 tts.start
    if text == conn.tts_first_text:
        logger.bind(tag=TAG).info(f"发送第一段语音: {text}")
-        conn.tts_start_speak_time = time.time()
+        conn.tts_start_speak_time = time.perf_counter()
    await send_tts_message(conn, "sentence_start", text)
-    # 发送 sentence_start（每个音频文件之前发送一次）
+    # 初始化流控参数
-    sentence_task = asyncio.create_task(
+    frame_duration = 60  # 毫秒
-        schedule_with_interrupt(base_delay, send_tts_message(conn, "sentence_start", text))
+    start_time = time.perf_counter()  # 使用高精度计时器
-    )
+    play_position = 0  # 已播放的时长（毫秒）
    conn.scheduled_tasks.append(sentence_task)
-    conn.tts_duration += duration
+    for opus_packet in audios:
        if conn.client_abort:
            return
-    # 发送音频数据
+        # 计算当前包的预期发送时间
-    for idx, opus_packet in enumerate(audios):
+        expected_time = start_time + (play_position / 1000)
        current_time = time.perf_counter()
        # 等待直到预期时间
        delay = expected_time - current_time
        if delay > 0:
            await asyncio.sleep(delay)
        # 发送音频包
        await conn.websocket.send(opus_packet)
-
+        play_position += frame_duration  # 更新播放位置
    await send_tts_message(conn, "sentence_end", text)
    # 发送结束消息（如果是最后一个文本）
    if conn.llm_finish_task and text == conn.tts_last_text:
-        stop_duration = conn.tts_duration - (time.time() - conn.tts_start_speak_time)
+        await send_tts_message(conn, 'stop', None)
-        stop_task = asyncio.create_task(
+        if await isLLMWantToFinish(text):
-            schedule_with_interrupt(stop_duration, send_tts_message(conn, 'stop'))
+            await conn.close()
        )
        conn.scheduled_tasks.append(stop_task)
        if await isLLMWantToFinish(conn):
            finish_task = asyncio.create_task(
                schedule_with_interrupt(stop_duration, await conn.close())
            )
            conn.scheduled_tasks.append(finish_task)
 async def send_tts_message(conn, state, text=None):
@@ -84,12 +82,3 @@ async def send_stt_message(conn, text):
            "session_id": conn.session_id}
        ))
    await send_tts_message(conn, "start")
 async def schedule_with_interrupt(delay, coro):
    """可中断的延迟调度"""
    try:
        await asyncio.sleep(delay)
        await coro
    except asyncio.CancelledError:
        pass
@@ -14,10 +14,9 @@ class TTSProvider(TTSProviderBase):
        self.access_token = config.get("access_token")
        self.cluster = config.get("cluster")
        self.voice = config.get("voice")
-
+        self.api_url = config.get("api_url")
-        self.host = "openspeech.bytedance.com"
+        self.authorization = config.get("authorization")
-        self.api_url = f"https://{self.host}/api/v1/tts"
+        self.header = {"Authorization": f"{self.authorization}{self.access_token}"}
        self.header = {"Authorization": f"Bearer;{self.access_token}"}
    def generate_filename(self, extension=".wav"):
        return os.path.join(self.output_file, f"tts-{datetime.now().date()}@{uuid.uuid4().hex}{extension}")
@@ -1,7 +1,5 @@
 import os
 import sys
 import asyncio
 from typing import List, Dict, Any
 # 添加项目根目录到Python路径
 current_dir = os.path.dirname(os.path.abspath(__file__))
@@ -10,10 +8,6 @@ sys.path.insert(0, project_root)
 from config.logger import setup_logging
 import importlib
 from datetime import datetime
 from core.utils.util import is_segment
 from core.utils.util import get_string_no_punctuation_or_emoji
 from core.utils.util import read_config, get_project_dir
 logger = setup_logging()
@@ -27,117 +21,3 @@ def create_instance(class_name, *args, **kwargs):
        return sys.modules[lib_name].LLMProvider(*args, **kwargs)
    raise ValueError(f"不支持的LLM类型: {class_name}，请检查该配置的type是否设置正确")
 async def test_single_model(llm_name: str, llm_config: Dict[str, Any], test_prompt: str, config: Dict[str, Any]) -> Dict[str, Any]:
    """异步测试单个模型"""
    try:
        # 获取实际的LLM类型
        llm_type = llm_config["type"] if "type" in llm_config else llm_name
        llm = create_instance(llm_type, llm_config)
        # 开始测试
        dialogue = []
        dialogue.append({"role": "system", "content": config.get("prompt")})
        dialogue.append({"role": "user", "content": test_prompt})
        start_time = datetime.now()
        llm_responses = llm.response("test", dialogue)
        response_message = []
        first_response_time = None
        total_response_time = None
        start = 0
        full_response = ""
        for content in llm_responses:
            response_message.append(content)
            full_response += content
            if is_segment(response_message):
                segment_text = "".join(response_message[start:])
                segment_text = get_string_no_punctuation_or_emoji(segment_text)
                if len(segment_text) > 0:
                    if first_response_time is None:
                        first_response_time = (datetime.now() - start_time).total_seconds()
                    start = len(response_message)
        total_response_time = (datetime.now() - start_time).total_seconds()
        return {
            "name": llm_name,
            "type": llm_type,
            "first_response_time": first_response_time,
            "total_response_time": total_response_time,
            "response_length": len(full_response),
            "status": "成功",
            "response": full_response
        }
    except Exception as e:
        print(f"测试 {llm_name} 时发生错误: {str(e)}")
        return {
            "name": llm_name,
            "type": llm_config.get("type", llm_name),
            "first_response_time": None,
            "total_response_time": None,
            "response_length": 0,
            "status": f"失败 - {str(e)}",
            "response": ""
        }
 async def main():
    """
    LLM模型响应速度测试和排行（异步版本）
    """
    config = read_config(get_project_dir() + "config.yaml")
    test_prompt = "你好小智"
    print("开始并发测试所有模型...")
    # 创建所有模型的测试任务
    tasks = []
    for llm_name, llm_config in config["LLM"].items():
        task = asyncio.create_task(test_single_model(llm_name, llm_config, test_prompt, config))
        tasks.append(task)
    # 等待所有测试完成
    test_results = await asyncio.gather(*tasks)
    # 打印测试结果排行榜
    print("\n========= LLM模型性能测试排行榜 =========")
    print("测试提示词:", test_prompt)
    # 过滤出成功的结果，并确保数值有效
    successful_results = [r for r in test_results if r["status"] == "成功" and r["first_response_time"] is not None]
    if successful_results:
        print("\n1. 首次响应时间排行:")
        sorted_by_first = sorted(successful_results, key=lambda x: x["first_response_time"])
        for i, result in enumerate(sorted_by_first, 1):
            print(f"{i}. {result['name']}({result['type']}) - {result['first_response_time']:.2f}秒")
            print(f"   响应内容: {result['response'][:50]}...")  # 只显示前50个字符
        print("\n2. 总响应时间排行:")
        sorted_by_total = sorted(successful_results, key=lambda x: x["total_response_time"] or float('inf'))
        for i, result in enumerate(sorted_by_total, 1):
            if result["total_response_time"] is not None:
                print(f"{i}. {result['name']}({result['type']}) - {result['total_response_time']:.2f}秒")
        print("\n3. 响应长度比较:")
        sorted_by_length = sorted(successful_results, key=lambda x: x["response_length"], reverse=True)
        for i, result in enumerate(sorted_by_length, 1):
            print(f"{i}. {result['name']}({result['type']}) - {result['response_length']}字符")
    else:
        print("\n没有成功完成测试的模型。")
    if len(test_results) != len(successful_results):
        print("\n测试失败的模型:")
        failed_results = [r for r in test_results if r["status"] != "成功" or r["first_response_time"] is None]
        for result in failed_results:
            print(f"- {result['name']}({result['type']}): {result['status']}")
 if __name__ == "__main__":
    # 运行异步主函数
    asyncio.run(main())
@@ -0,0 +1,33 @@
 import struct
 def decode_opus_from_file(input_file):
    """
    从p3文件中解码 Opus 数据，并返回一个 Opus 数据包的列表以及总时长。
    """
    opus_datas = []
    total_frames = 0
    sample_rate = 16000  # 文件采样率
    frame_duration_ms = 60  # 帧时长
    frame_size = int(sample_rate * frame_duration_ms / 1000)
    with open(input_file, 'rb') as f:
        while True:
            # 读取头部（4字节）：[1字节类型，1字节保留，2字节长度]
            header = f.read(4)
            if not header:
                break
            # 解包头部信息
            _, _, data_len = struct.unpack('>BBH', header)
            # 根据头部指定的长度读取 Opus 数据
            opus_data = f.read(data_len)
            if len(opus_data) != data_len:
                raise ValueError(f"Data length({len(opus_data)}) mismatch({data_len}) in the file.")
            opus_datas.append(opus_data)
            total_frames += 1
    # 计算总时长
    total_duration = (total_frames * frame_duration_ms) / 1000.0
    return opus_datas, total_duration
@@ -2,8 +2,6 @@ import os
 import sys
 from config.logger import setup_logging
 import importlib
 from datetime import datetime
 from core.utils.util import read_config, get_project_dir
 logger = setup_logging()
@@ -16,26 +14,4 @@ def create_instance(class_name, *args, **kwargs):
            sys.modules[lib_name] = importlib.import_module(f'{lib_name}')
        return sys.modules[lib_name].TTSProvider(*args, **kwargs)
-    raise ValueError(f"不支持的TTS类型: {class_name}，请检查该配置的type是否设置正确")
+    raise ValueError(f"不支持的TTS类型: {class_name}，请检查该配置的type是否设置正确")
 if __name__ == "__main__":
    """
      响应速度测试
    """
    config = read_config(get_project_dir() + "config.yaml")
    tts = create_instance(
        config["selected_module"]["TTS"]
        if not 'type' in config["TTS"][config["selected_module"]["TTS"]]
        else
        config["TTS"][config["selected_module"]["TTS"]]["type"],
        config["TTS"][config["selected_module"]["TTS"]],
        config["delete_audio"]
    )
    tts.output_file = get_project_dir() + tts.output_file
    start = datetime.now()
    file_path = tts.to_tts("你好，测试,我是人工智能小智")
    print("语音合成耗时：" + str(datetime.now() - start))
    start = datetime.now()
    tts.wav_to_opus_data(file_path)
    print("语音opus耗时：" + str(datetime.now() - start))
@@ -3,6 +3,7 @@ import re
 import json
 import yaml
 import socket
 import subprocess
 def get_project_dir():
@@ -34,13 +35,6 @@ def write_json_file(file_path, data):
        json.dump(data, file, ensure_ascii=False, indent=4)
 def is_segment(tokens):
    if tokens[-1] in (",", ".", "?", "，", "。", "？", "！", "!", ";", "；", ":", "："):
        return True
    else:
        return False
 def is_punctuation_or_emoji(char):
    """检查字符是否为空格、指定标点或表情符号"""
    # 定义需要去除的中英文标点（包括全角/半角）
@@ -121,3 +115,29 @@ def check_password(password):
    # 如果满足所有条件，则返回True
    return True
 def check_ffmpeg_installed():
    ffmpeg_installed = False
    try:
        # 执行ffmpeg -version命令，并捕获输出
        result = subprocess.run(
            ['ffmpeg', '-version'],
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True,
            check=True  # 如果返回码非零则抛出异常
        )
        # 检查输出中是否包含版本信息（可选）
        output = result.stdout + result.stderr
        if 'ffmpeg version' in output.lower():
            ffmpeg_installed = True
        return False
    except (subprocess.CalledProcessError, FileNotFoundError):
        # 命令执行失败或未找到
        ffmpeg_installed = False
    if not ffmpeg_installed:
        error_msg = "您的电脑还没正确安装ffmpeg\n"
        error_msg += "\n建议您：\n"
        error_msg += "1、按照项目的安装文档，正确进入conda环境\n"
        error_msg += "2、查阅安装文档，如何在conda环境中安装ffmpeg\n"
        raise ValueError(error_msg)
@@ -159,14 +159,31 @@ poetry run python app.py
 本项目使用`conda`管理依赖环境。如果不方便安装`conda`，需要根据实际的操作系统安装好`libopus`和`ffmpeg`。
 如果确定使用`conda`，则安装好后，开始执行以下命令。
 重要提示！windows 用户，可以通过安装`Anaconda`来管理环境。安装好`Anaconda`后，在`开始`那里搜索`anaconda`相关的关键词，
 找到`Anaconda Prpmpt`，使用管理员身份运行它。如下图。
 ![conda_prompt](./images/conda_env_1.png)
 运行之后，如果你能看到命令行窗口前面有一个(base)字样，说明你成功进入了`conda`环境。那么你就可以执行以下命令了。
 ![conda_env](./images/conda_env_2.png)
 ```
 conda remove -n xiaozhi-esp32-server --all -y
 conda create -n xiaozhi-esp32-server python=3.10 -y
 conda activate xiaozhi-esp32-server
-conda install conda-forge::libopus -y
+
-conda install conda-forge::ffmpeg -y
+# 添加清华源通道
 conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
 conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free
 conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge
 conda install libopus -y
 conda install ffmpeg -y
 ```
 请注意，以上命令，不是一股脑执行就成功的，你需要一步步执行，每一步执行完后，都检查一下输出的日志，查看是否成功。
 ## 2.安装本项目依赖
 你先要下载本项目源码，源码可以通过`git clone`命令下载，如果你不熟悉`git clone`命令。
@@ -179,7 +196,7 @@ conda install conda-forge::ffmpeg -y
 你需要把它重命名成`xiaozhi-esp32-server`，好了请记住这个目录，我们暂且称它为`项目目录`。
 ```
-# 使用dos或者终端，进入到你的项目目录，执行以下命令
+# 继续使用conda环境，进入到你的项目目录，执行以下命令
 conda activate xiaozhi-esp32-server
 pip config set global.index-url https://mirrors.aliyun.com/pypi/simple/
 pip install -r requirements.txt
@@ -250,7 +267,7 @@ LLM:
 ## 模型文件
 本项目语音识别模型，默认使用`SenseVoiceSmall`模型，进行语音转文字。因为模型较大，需要独立下载，下载后把`model.pt`
-文件放在`model/SenseVoiceSmall`
+文件放在`models/SenseVoiceSmall`
 目录下。下面两个下载路线任选一个。
 - 线路一：阿里魔塔下载[SenseVoiceSmall](https://modelscope.cn/models/iic/SenseVoiceSmall/resolve/master/model.pt)
Author	SHA1	Message	Date
欣南科技 GitHub Junsen hrz	effd79b465	Tts302 (#170 ) * feat: add 302.ai TTS integration (#166) * update:将tts_302ai tts合并到doubao tts --------- Co-authored-by: Junsen <66542771+Huang-junsen@users.noreply.github.com> Co-authored-by: hrz <1710360675@qq.com>	2025-03-02 16:59:25 +08:00
HonestQiao GitHub hrz	bc531652e9	音乐播放功能添加p3文件格式支持，添加文件目录(含子目录)扫描和文件列表刷新功能 (#157 ) Co-authored-by: hrz <1710360675@qq.com>	2025-03-01 17:57:43 +08:00
欣南科技 GitHub hrz	1c5581b765	Fix ffmpeg env (#163 ) * update:ffmpeg依赖检查 * update:微信群更换发布方式 --------- Co-authored-by: hrz <1710360675@qq.com>	2025-03-01 17:34:14 +08:00
欣南科技 GitHub hrz	b486599ab8	update:ffmpeg依赖检查 (#162 ) Co-authored-by: hrz <1710360675@qq.com>	2025-03-01 17:09:01 +08:00
欣南科技 GitHub hrz	b94842c312	Fix long audio bug (#158 ) * update:异步生成音频 * update:优化LLM断句 --------- Co-authored-by: hrz <1710360675@qq.com>	2025-03-01 01:54:55 +08:00
欣南科技 GitHub hrz	2c88a36f32	update:启动时检查配置文件 (#155 ) Co-authored-by: hrz <1710360675@qq.com>	2025-02-28 19:17:36 +08:00
欣南科技 GitHub hrz	242f4d87e7	Qq group (#146 ) * update:qq group * update:更新英文版说明 --------- Co-authored-by: hrz <1710360675@qq.com>	2025-02-26 16:02:59 +08:00
欣南科技 GitHub hrz	2255aacfd0	update:qq group (#145 ) Co-authored-by: hrz <1710360675@qq.com>	2025-02-26 15:10:12 +08:00