TW_TTS语音合成系列教程——TW_TTS和其它单片机串口通讯范例

hcm0915

概述：

• TW_TTS共有六个引脚，分别是——地：G，电源：V(5V)，输入：R，输出：T，喇叭+：SPK+(红线)，喇叭-：SPK-(黑线)
  

注意： a. 语音模块使用 G、V、R 三引脚连接方案时，支持对语音合成播放模式的控制

           b. 语音模块使用 G、V、R、T 四引脚连接方案时，满足原方案应用的同时，还具备语音合成芯片状态的查询功能  

• 支持简体中文及英文单字母合成，兼容GB2312和UTF-8编码，能智能解析标点、多音字与数字，还可通过标记自定义发音和停顿，单次合成文本不超4K字节。
  
• 模块提供10级音量、语速、语调可调，默认中等档位，同时支持暂停、继续、停止合成等控制指令，操作灵活，满足不同场景下的语音输出需求。
  
• 内置15种提示音效，含5首铃声、5首信息提示音和5首警示音，分类清晰，可直接调用对应音效，丰富语音交互的多样性。
  
• 采用9600波特率的串口协议，1位起始位、8位数据位、1位停止位且无校验，通讯参数明确，连接上位机或MCU便捷。
  

语音合成模块指令协议表

可以通过连接电脑进行串口指令调试：

指令类型	指令格式（十六进制）	参数说明
播放实例（好好搭搭）	0xFD 0x00 0x0A 0x01 0x00 0xBA 0xC3 0xBA 0xC3 0xB4 0xEE 0xB4 0xEE	固定指令，用于播放 “好好搭搭” 音频
音量调整	0xFD 0x00 0x06 0x01 0x01 0x5B 0x76 0x(30-39) 0x5D	0x30-0x39对应音量 [v0]- [v9]- v0音量最小，v9 音量最大- 默认音量 v5（对应 0x35）
语速调整	0xFD 0x00 0x06 0x01 0x01 0x5B 0x73 0x(30-39) 0x5D	0x30-0x39 对应语速 [s0]-[s9]- s0语速最快，s9语速最慢- 默认语速 s5（对应 0x35）
语调调整	0xFD 0x00 0x06 0x01 0x01 0x5B 0x74 0x(30-39) 0x5D	- 0x30-0x39 对应语调 [t0]-[t9]- t0语调最低，t9 语调最高- 默认语调 t5（对应 0x35）
停止合成	0xFD 0x00 0x01 0x02	无额外参数
暂停合成	0xFD 0x00 0x01 0x03	无额外参数
继续合成	0xFD 0x00 0x01 0x04	无额外参数
铃声播放	0xFD 0x00 0x08 0x01 0x01 0x72 0x69 0x6E 0x67 0x5F 0x(31-35)	0x31-0x35对应铃声 1-5
提示音播放	0xFD 0x00 0x0B 0x01 0x01 0x6D 0x65 0x73 0x73 0x61 0x67 0x65 0x5F 0x(31-35)	0x31-0x35对应提示音 1-5
警示音播放	0xFD 0x00 0x09 0x01 0x01 0x61 0x6C 0x65 0x72 0x74 0x5F 0x(31-35)	0x31-0x35 对应警示音 1-5
查询播放状态	0xFD 0x00 0x01 0x21	无额外参数
播放状态返回值	-	0x4E：播放中 0x4F：空闲状态

STC89C52--C51

电路连接：

单片机的P3_0引脚（RX）连接语音合成模块的T引脚，单片机的P3_1引脚（TX）连接语音合成模块的R引脚

范例： C51串口控制播放语音

程序效果：

语音合成模块接入电源上电以后，C51单片机收到指令，控制语音合成播放“初始化完成”之后循环播放”你好“

STM32

电路连接：

STM32的PA9（TX）引脚接TW_TTS的（R）引脚，STM32的PA10（RX）引脚接TW_TTS的（T）引脚。

范例： stm32串口控制播放语音

TW_TTS.c

1. #include "usart.h"         
2. #include "TW_TTS.h"
3. #include <string.h>
5. // static  TTS_PLAY[] = {0xfd, 0x00, 0x0a, 0x01, 0x00, 0xba, 0xc3, 0xba, 0xc3, 0xb4, 0xee, 0xb4, 0xee};
6. static uint8_t  TTS_VOLUME_CMD[] = {0xfd, 0x00, 0x06, 0x01, 0x01, 0x5b, 0x76, 0x30, 0x5d};
7. static uint8_t  TTS_SPEED_CMD[] = {0xfd, 0x00, 0x06, 0x01, 0x01, 0x5b, 0x73, 0x30, 0x5d};
8. static uint8_t  TTS_TONE_CMD[] = {0xfd, 0x00, 0x06, 0x01, 0x01, 0x5b, 0x74, 0x30, 0x5d};
9. static uint8_t  TTS_STOP_CMD[] = {0xfd, 0x00, 0x01, 0x02};
10. static uint8_t  TTS_PAUSE_CMD[] = {0xfd, 0x00, 0x01, 0x03};
11. static uint8_t  TTS_RESUME_CMD[] = {0xfd, 0x00, 0x01, 0x04};
12. static uint8_t  TTS_QUERY_CMD[] = {0xFD, 0x00, 0x02, 0x21, 0x00};
15. void tts_writeData(unsigned char *DAT, unsigned char len)
16. {
17.         HAL_UART_Transmit(&huart1,DAT,len,100);
18. }
20. /**
21. * @brief 播放函数
22. * @param str 播放内容（字符串）
23. */
24. void TTS_play(unsigned char* str)
25. {
26.     unsigned  char  Frame_Info[50];
27.     uint16_t str_len = 0;
28.     str_len = strlen((char*)str);
29.    
30.     if (str_len == 0 || str_len > 4094) {
31.         return;
32.     }
34.     Frame_Info[0] = 0xFD ;                        
35.     Frame_Info[1] = 0x00 ;                        
36.     Frame_Info[2] = str_len + 2;               
37.     Frame_Info[3] = 0x01 ;                        
38.     Frame_Info[4] = 0x00;
40.     // // 设置帧头后的数据长度字段
41.     Frame_Info[1] = (str_len + 2) >> 8;
42.     Frame_Info[2] = (str_len + 2) & 0xFF;
43.     // 发送帧头
44.                 memcpy(&Frame_Info[5], str, str_len);
45.                
46.     tts_writeData(Frame_Info, 5+str_len);
47.                
48. }
50. /**
51. * @brief 设置音量
52. * @param vol 音量值，范围0-9，默认5
53. */
54. void TTS_volume(uint8_t vol)
55. {
56.     uint8_t volume_buf[9];
57.     uint8_t i;
58.    
59.     if (vol > 9)
60.     {
61.         vol = 9;
62.     }
63.    
64.     // 复制常量数据到临时数组
65.     for(i = 0; i < 9; i++)
66.     {
67.         volume_buf = TTS_VOLUME_CMD;
68.     }
69.    
70.     volume_buf[7] = 0x30 + vol;
71.     tts_writeData(volume_buf, 9);
72. }
74. /**
75. * @brief 设置播放速度
76. * @param speed 速度值，范围0-9，默认5
77. */
78. void TTS_speed(uint8_t speed)
79. {
80.     uint8_t speed_buf[9];
81.     uint8_t i;
82.    
83.     if (speed > 9)
84.     {
85.         speed = 9;
86.     }
87.    
88.     // 复制常量数据到临时数组
89.     for(i = 0; i < 9; i++)
90.     {
91.         speed_buf = TTS_SPEED_CMD;
92.     }
93.    
94.     speed_buf[7] = 0x30 + speed;
95.     tts_writeData(speed_buf, 9);
96. }
98. /**
99. * @brief 设置语调
100. * @param tone 语调值，范围0-9，默认5
101. */
102. void TTS_tone(uint8_t tone)
103. {
104.     uint8_t tone_buf[9];
105.     uint8_t i;
106.    
107.     if (tone > 9)
108.     {
109.         tone = 9;
110.     }
111.    
112.     // 复制常量数据到临时数组
113.     for(i = 0; i < 9; i++)
114.     {
115.         tone_buf = TTS_TONE_CMD;
116.     }
117.    
118.     tone_buf[7] = 0x30 + tone;
119.     tts_writeData(tone_buf, 9);
120. }
122. /**
123. * @brief 播报警示音
124. * @param alert 警示音标号，1-5
125. */
126. void TTS_alert(uint8_t alert)
127. {
128.     unsigned char str[8];
129.    
130.     if (alert < 1)
131.     {
132.         alert = 1;
133.     }
134.     else if (alert > 5)
135.     {
136.         alert = 5;
137.     }
138.    
139.     // 直接构造字符串，避免使用字符串常量
140.     str[0] = 'a';
141.     str[1] = 'l';
142.     str[2] = 'e';
143.     str[3] = 'r';
144.     str[4] = 't';
145.     str[5] = '_';
146.     str[6] = 0x30 + alert;
147.     str[7] = '\0';
148.    
149.     TTS_play(str);
150. }
152. /**
153. * @brief 播报信息提示音
154. * @param msg 标号，1-5
155. */
156. void TTS_play_msg(uint8_t msg)
157. {
158.     unsigned char str[10];
159.    
160.     if (msg < 1)
161.     {
162.         msg = 1;
163.     }
164.     else if (msg > 5)
165.     {
166.         msg = 5;
167.     }
168.    
169.     str[0] = 'm';
170.     str[1] = 'e';
171.     str[2] = 's';
172.     str[3] = 's';
173.     str[4] = 'a';
174.     str[5] = 'g';
175.     str[6] = 'e';
176.     str[7] = '_';
177.     str[8] = 0x30 + msg;
178.     str[9] = '\0';
179.    
180.     TTS_play(str);
181. }
183. /**
184. * @brief 播放铃声
186. * @param ring 标号，1-5
187. */
188. void TTS_play_ring(uint8_t ring)
189. {
190.     unsigned char str[7];
191.    
192.     if (ring < 1)
193.     {
194.         ring = 1;
195.     }
196.     else if (ring > 5)
197.     {
198.         ring = 5;
199.     }
200.    
201.     str[0] = 'r';
202.     str[1] = 'i';
203.     str[2] = 'n';
204.     str[3] = 'g';
205.     str[4] = '_';
206.     str[5] = 0x30 + ring;
207.     str[6] = '\0';
208.    
209.     TTS_play(str);
210. }
212. /**
213. * @brief 停止播放
214. */
215. void TTS_stop(void)
216. {
217.     uint8_t TW_tts_buf[4];
218.     uint8_t i;
219.    
220.     // 复制常量数据到临时数组
221.     for(i = 0; i < 4; i++)
222.     {
223.         TW_tts_buf = TTS_STOP_CMD;
224.     }
225.    
226.     tts_writeData(TW_tts_buf, 4);
227. }
229. /**
230. * @brief 暂停播放
231. */
232. void TTS_pause(void)
233. {
234.     uint8_t TW_tts_buf[4];
235.     uint8_t i;
236.    
237.     // 复制常量数据到临时数组
238.     for(i = 0; i < 4; i++)
239.     {
240.         TW_tts_buf = TTS_PAUSE_CMD;
241.     }
242.    
243.     tts_writeData(TW_tts_buf, 4);
244. }
246. /**
247. * @brief 继续播放
248. */
249. void TTS_resume(void)
250. {
251.     uint8_t TW_tts_buf[4];
252.     uint8_t i;
253.    
254.     // 复制常量数据到临时数组
255.     for(i = 0; i < 4; i++)
256.     {
257.         TW_tts_buf = TTS_RESUME_CMD;
258.     }
259.    
260.     tts_writeData(TW_tts_buf, 4);
261. }
263. /**
264. * @brief 读取CITW-TTS芯片当前播放状态
266. */
267. uint8_t TTS_queryState(uint8_t response)
268. {
269.     uint8_t query_buf[5];
270.     uint8_t i;
271.    
272.     // 复制常量数据到临时数组
273.     for(i = 0; i < 5; i++)
274.     {
275.         query_buf = TTS_QUERY_CMD;
276.     }
277.    
278.     // 发送查询命令
279.     tts_writeData(query_buf, 5);
280.    
281.     // 短暂延时等待响应
282.     HAL_Delay(10);
283.     // 检查串口接收标志
284.    
285.     if (response == 0x4E)
286.     {
287.         return TTS_STATE_PLAYING; // 播放中
288.     }
289.     else if (response == 0x4F)
290.     {
291.         return TTS_STATE_IDLE;    // 空闲
292.     }
293.     else if (response == 0x4A)
294.     {
295.         return TTS_STATE_INIT;   // 初始化
296.     }
297.     else if (response == 0x41)
298.     {
299.         return TTS_STATE_CHECK;   // 检查
300.     }
301.     else
302.     {
303.         return TTS_STATE_ERROR;   // 查询失败（命令错误）
304.     }
305. }

复制代码

TW_TTS.h

1. #ifndef __TW_TTS_H
2. #define __TW_TTS_H
4. #define TTS_STATE_ERROR   0   // 查询失败（命令错误）
5. #define TTS_STATE_PLAYING 1   // 播放中（对应芯片返回0x4E）
6. #define TTS_STATE_IDLE    2   // 空闲（对应芯片返回0x4F）
7. #define TTS_STATE_INIT    3   // 初始化（对应芯片返回0x4A）
8. #define TTS_STATE_CHECK   4   // 检查（对应芯片返回0x41）
10. void tts_writeData(unsigned char *DAT, unsigned char len);
11. void TTS_play(unsigned char* str);
12. void TTS_volume(uint8_t vol);
13. void TTS_speed(uint8_t speed);
14. void TTS_tone(uint8_t tone);
15. void TTS_alert(uint8_t alert);
16. void TTS_play_msg(uint8_t msg);
17. void TTS_play_ring(uint8_t ring);
18. void TTS_stop(void);
19. void TTS_pause(void);
20. void TTS_resume(void);
21. uint8_t TTS_queryState(uint8_t response);
23. #endif
25. uart.c
26. /**
27.   ******************************************************************************
28.   * @file    usart.c
29.   * @brief   This file provides code for the configuration
30.   *          of the USART instances.
31.   ******************************************************************************
32.   * @attention
33.   *
34.   * <h2><center>© Copyright (c) 2025 STMicroelectronics.
35.   * All rights reserved.</center></h2>
36.   *
37.   * This software component is licensed by ST under BSD 3-Clause license,
38.   * the "License"; You may not use this file except in compliance with the
39.   * License. You may obtain a copy of the License at:
40.   *                        opensource.org/licenses/BSD-3-Clause
41.   *
42.   ******************************************************************************
43.   */
45. /* Includes ------------------------------------------------------------------*/
46. #include "usart.h"
48. /* USER CODE BEGIN 0 */
50. /* USER CODE END 0 */
52. UART_HandleTypeDef huart1;
53. UART_HandleTypeDef huart2;
55. /* USART1 init function */
57. void MX_USART1_UART_Init(void)
58. {
60.   huart1.Instance = USART1;
61.   huart1.Init.BaudRate = 9600;
62.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
63.   huart1.Init.StopBits = UART_STOPBITS_1;
64.   huart1.Init.Parity = UART_PARITY_NONE;
65.   huart1.Init.Mode = UART_MODE_TX_RX;
66.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
67.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
68.   if (HAL_UART_Init(&huart1) != HAL_OK)
69.   {
70.     Error_Handler();
71.   }
73. }
74. /* USART2 init function */
76. void MX_USART2_UART_Init(void)
77. {
79.   huart2.Instance = USART2;
80.   huart2.Init.BaudRate = 9600;
81.   huart2.Init.WordLength = UART_WORDLENGTH_8B;
82.   huart2.Init.StopBits = UART_STOPBITS_1;
83.   huart2.Init.Parity = UART_PARITY_NONE;
84.   huart2.Init.Mode = UART_MODE_TX_RX;
85.   huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
86.   huart2.Init.OverSampling = UART_OVERSAMPLING_16;
87.   if (HAL_UART_Init(&huart2) != HAL_OK)
88.   {
89.     Error_Handler();
90.   }
92. }
94. void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
95. {
97.   GPIO_InitTypeDef GPIO_InitStruct = {0};
98.   if(uartHandle->Instance==USART1)
99.   {
100.   /* USER CODE BEGIN USART1_MspInit 0 */
102.   /* USER CODE END USART1_MspInit 0 */
103.     /* USART1 clock enable */
104.     __HAL_RCC_USART1_CLK_ENABLE();
106.     __HAL_RCC_GPIOA_CLK_ENABLE();
107.     /**USART1 GPIO Configuration
108.     PA9     ------> USART1_TX
109.     PA10     ------> USART1_RX
110.     */
111.     GPIO_InitStruct.Pin = GPIO_PIN_9;
112.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
113.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
114.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
116.     GPIO_InitStruct.Pin = GPIO_PIN_10;
117.     GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
118.     GPIO_InitStruct.Pull = GPIO_NOPULL;
119.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
121.     /* USART1 interrupt Init */
122.     HAL_NVIC_SetPriority(USART1_IRQn, 0, 0);
123.     HAL_NVIC_EnableIRQ(USART1_IRQn);
124.   /* USER CODE BEGIN USART1_MspInit 1 */
126.   /* USER CODE END USART1_MspInit 1 */
127.   }
128.   else if(uartHandle->Instance==USART2)
129.   {
130.   /* USER CODE BEGIN USART2_MspInit 0 */
132.   /* USER CODE END USART2_MspInit 0 */
133.     /* USART2 clock enable */
134.     __HAL_RCC_USART2_CLK_ENABLE();
136.     __HAL_RCC_GPIOA_CLK_ENABLE();
137.     /**USART2 GPIO Configuration
138.     PA2     ------> USART2_TX
139.     PA3     ------> USART2_RX
140.     */
141.     GPIO_InitStruct.Pin = GPIO_PIN_2;
142.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
143.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
144.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
146.     GPIO_InitStruct.Pin = GPIO_PIN_3;
147.     GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
148.     GPIO_InitStruct.Pull = GPIO_NOPULL;
149.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
151.     /* USART2 interrupt Init */
152.     HAL_NVIC_SetPriority(USART2_IRQn, 0, 0);
153.     HAL_NVIC_EnableIRQ(USART2_IRQn);
154.   /* USER CODE BEGIN USART2_MspInit 1 */
156.   /* USER CODE END USART2_MspInit 1 */
157.   }
158. }
160. void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
161. {
163.   if(uartHandle->Instance==USART1)
164.   {
165.   /* USER CODE BEGIN USART1_MspDeInit 0 */
167.   /* USER CODE END USART1_MspDeInit 0 */
168.     /* Peripheral clock disable */
169.     __HAL_RCC_USART1_CLK_DISABLE();
171.     /**USART1 GPIO Configuration
172.     PA9     ------> USART1_TX
173.     PA10     ------> USART1_RX
174.     */
175.     HAL_GPIO_DeInit(GPIOA, GPIO_PIN_9|GPIO_PIN_10);
177.     /* USART1 interrupt Deinit */
178.     HAL_NVIC_DisableIRQ(USART1_IRQn);
179.   /* USER CODE BEGIN USART1_MspDeInit 1 */
181.   /* USER CODE END USART1_MspDeInit 1 */
182.   }
183.   else if(uartHandle->Instance==USART2)
184.   {
185.   /* USER CODE BEGIN USART2_MspDeInit 0 */
187.   /* USER CODE END USART2_MspDeInit 0 */
188.     /* Peripheral clock disable */
189.     __HAL_RCC_USART2_CLK_DISABLE();
191.     /**USART2 GPIO Configuration
192.     PA2     ------> USART2_TX
193.     PA3     ------> USART2_RX
194.     */
195.     HAL_GPIO_DeInit(GPIOA, GPIO_PIN_2|GPIO_PIN_3);
197.     /* USART2 interrupt Deinit */
198.     HAL_NVIC_DisableIRQ(USART2_IRQn);
199.   /* USER CODE BEGIN USART2_MspDeInit 1 */
201.   /* USER CODE END USART2_MspDeInit 1 */
202.   }
203. }
205. /* USER CODE BEGIN 1 */
207. /* USER CODE END 1 */
209. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

复制代码

main.c

1. /* USER CODE BEGIN Header */
2. /**
3.   ******************************************************************************
4.   * @file           : main.c
5.   * @brief          : Main program body
6.   ******************************************************************************
7.   * @attention
8.   *
9.   * <h2><center>© Copyright (c) 2025 STMicroelectronics.
10.   * All rights reserved.</center></h2>
11.   *
12.   * This software component is licensed by ST under BSD 3-Clause license,
13.   * the "License"; You may not use this file except in compliance with the
14.   * License. You may obtain a copy of the License at:
15.   *                        opensource.org/licenses/BSD-3-Clause
16.   *
17.   ******************************************************************************
18.   */
19. /* USER CODE END Header */
20. /* Includes ------------------------------------------------------------------*/
21. #include "main.h"
22. #include "usart.h"
23. #include "gpio.h"
24. #include "TW_TTS.h"
25. /* Private includes ----------------------------------------------------------*/
26. /* USER CODE BEGIN Includes */
27. uint8_t rec1Byte;
28. uint8_t rec2Byte;
29. /* USER CODE END Includes */
31. /* Private typedef -----------------------------------------------------------*/
32. /* USER CODE BEGIN PTD */
34. /* USER CODE END PTD */
36. /* Private define ------------------------------------------------------------*/
37. /* USER CODE BEGIN PD */
38. /* USER CODE END PD */
40. /* Private macro -------------------------------------------------------------*/
41. /* USER CODE BEGIN PM */
43. /* USER CODE END PM */
45. /* Private variables ---------------------------------------------------------*/
47. /* USER CODE BEGIN PV */
49. /* USER CODE END PV */
51. /* Private function prototypes -----------------------------------------------*/
52. void SystemClock_Config(void);
53. /* USER CODE BEGIN PFP */
55. /* USER CODE END PFP */
57. /* Private user code ---------------------------------------------------------*/
58. /* USER CODE BEGIN 0 */
60. /* USER CODE END 0 */
62. /**
63.   * @brief  The application entry point.
64.   * @retval int
65.   */
66. int main(void)
67. {
68.   /* USER CODE BEGIN 1 */
70.   /* USER CODE END 1 */
72.   /* MCU Configuration--------------------------------------------------------*/
74.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
75.   HAL_Init();
77.   /* USER CODE BEGIN Init */
79.   /* USER CODE END Init */
81.   /* Configure the system clock */
82.   SystemClock_Config();
84.   /* USER CODE BEGIN SysInit */
86.   /* USER CODE END SysInit */
88.   /* Initialize all configured peripherals */
89.   MX_GPIO_Init();
90.   MX_USART1_UART_Init();
91.   MX_USART2_UART_Init();
92.   /* USER CODE BEGIN 2 */
93.         HAL_UART_Receive_IT(&huart1, &rec1Byte, sizeof(rec1Byte));//打开串口接收中断
94.         HAL_UART_Receive_IT(&huart2, &rec2Byte, sizeof(rec2Byte));//打开串口接收中断
95.   /* USER CODE END 2 */
97.   /* Infinite loop */
98.   /* USER CODE BEGIN WHILE */
99.         TTS_volume(1);
100.   while (1)
101.   {
102.                
103.     /* USER CODE END WHILE */
105.     /* USER CODE BEGIN 3 */
106.                 if(TTS_queryState(rec1Byte)==TTS_STATE_INIT)
107.                 {
108.                         HAL_Delay(100);
109.                         TTS_play("初始化完成");
110.                         HAL_Delay(2000);
111.                 }
112.                 TTS_play("好好搭搭");
113. HAL_Delay(2000);
114.   }
115.   /* USER CODE END 3 */
116. }
118. /**
119.   * @brief System Clock Configuration
120.   * @retval None
121.   */
122. void SystemClock_Config(void)
123. {
124.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
125.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
127.   /** Initializes the RCC Oscillators according to the specified parameters
128.   * in the RCC_OscInitTypeDef structure.
129.   */
130.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
131.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
132.   RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
133.   RCC_OscInitStruct.HSIState = RCC_HSI_ON;
134.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
135.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
136.   RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
137.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
138.   {
139.     Error_Handler();
140.   }
141.   /** Initializes the CPU, AHB and APB buses clocks
142.   */
143.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
144.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
145.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
146.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
147.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
148.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
150.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
151.   {
152.     Error_Handler();
153.   }
154. }
156. /* USER CODE BEGIN 4 */
157. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
158. {
159.                 if (huart == &huart1)
160.                 {
161.        HAL_UART_Transmit(&huart2, &rec1Byte, 1, 100);
162.                 }
163.                
164.                 HAL_UART_Receive_IT(&huart1, &rec1Byte, 1);
165.                
166.                 if (huart == &huart2)
167.                 {
168.        HAL_UART_Transmit(&huart2, &rec2Byte, 1, 100);
169.                 }
170.                 HAL_UART_Receive_IT(&huart2, &rec2Byte, 1);
171. }
172. /* USER CODE END 4 */
174. /**
175.   * @brief  This function is executed in case of error occurrence.
176.   * @retval None
177.   */
178. void Error_Handler(void)
179. {
180.   /* USER CODE BEGIN Error_Handler_Debug */
181.   /* User can add his own implementation to report the HAL error return state */
182.   __disable_irq();
183.   while (1)
184.   {
185.   }
186.   /* USER CODE END Error_Handler_Debug */
187. }
189. #ifdef  USE_FULL_ASSERT
190. /**
191.   * @brief  Reports the name of the source file and the source line number
192.   *         where the assert_param error has occurred.
193.   * @param  file: pointer to the source file name
194.   * @param  line: assert_param error line source number
195.   * @retval None
196.   */
197. void assert_failed(uint8_t *file, uint32_t line)
198. {
199.   /* USER CODE BEGIN 6 */
200.   /* User can add his own implementation to report the file name and line number,
201.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
202.   /* USER CODE END 6 */
203. }
204. #endif /* USE_FULL_ASSERT */
206. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

复制代码

程序效果：

语音合成模块上电播放：“初始化完成”，之后每两秒播放一次“好好搭搭”

串口1用于控制语音合成模块，串口2查看语音合成播放的信息。

Arduino

电路连接：

Arduino端程序

范例：Arduino控制语音合成播放

1. #include "Arduino.h"
2. #include "Wire.h"
3. #include "Servo.h"
4. #include "SoftwareSerial.h"
5. #include "TW_TTS.h"
7. TW_TTS syn;
9. void setup()
10. {
11.   syn.begin();
12. }
14. void loop()
15. {
16.   if(syn.tts_queryState()==TTS_STATE_INIT){
17.     syn.tts_play("初始化完成");
18.     delay(2000);
19.   }
20.   syn.tts_play("你好");
21.   delay(2000);
22. }

复制代码

程序效果：

语音合成模块上电播放：“初始化完成”，之后每两秒播放一次“你好”

esp32

电路连接：

esp32c3的引脚0（TX）连接语音合成模块的R引脚，esp32c3的引脚1（RX）连接语音合成模块的T引脚

范例： esp32实时天气时钟播报（好搭 Block 案例）

范例： esp32实时天气时钟播报（字符代码编程案例）

TW_TTS.py

1. from machine import UART
2. from machine import Pin
4. TTS_STATE_ERROR = 0   
5. TTS_STATE_PLAYING = 1   
6. TTS_STATE_IDLE = 2   
7. TTS_STATE_INIT = 3   
8. TTS_STATE_CHECK = 4   
10. '''
11. 协议格式
12. 帧头    数据长度     命令字    编码参数     文本
13. 0xfd    0x00 0xLL   0x01      0x00        text(n字节)
14. '''
15. class TW_TTS:
16.     #全局变量，保存编码格式
17.     #0x00:GB2312编码,目前只支持GB2312
18.     global code_type
19.     code_type = 0x0
20.     def __init__(self,tx_pin,rx_pin):
21.         self.uart = UART(1, baudrate=9600, tx=tx_pin, rx=rx_pin, timeout=10)
23.     #向芯片发送数据
24.     def write(self,dat):
25.         if type(dat) == type('a'):
26.             self.uart.write(dat)
27.         else:
28.             self.uart.write(bytes(dat))
30.     #设置文字编码
31.     def set_code(self,code):
32.         global code_type
33.         code_type = code
34.    
35.     #播放语音
36.     def play(self, str):
37.         global code_type
38.         asr_tts_buf = [0xfd,0x00,0x00,0x01,code_type]
39.         #最大支持4K字节文本
40.         asr_tts_buf[1] = (len(str) + 2)//256        
41.         asr_tts_buf[2] = (len(str) + 2)%256            
42.         asr_tts_buf.extend(str)
43.         # print(asr_tts_buf)
44.         self.uart.write(bytes(asr_tts_buf))
46.     #设置音量，vol:音量：0-9,默认5,音量0为静音
47.     def volume(self,vol):
48.         volume_buf = [0xfd,0x00,0x06,0x01,0x01,0x5b,0x76,0x30,0x5d]
49.         volume_buf[7] = (0x30 + vol)
50.         self.uart.write(bytes(volume_buf))
51.    
52.     #设置语音播报速度 0-9,默认5
53.     def speed(self,spd):
54.         speed_buf = [0xfd,0x00,0x06,0x01,0x01,0x5b,0x73,0x30,0x5d]
55.         speed_buf[7] = (0x30 + spd)
56.         self.uart.write(bytes(speed_buf))      
57.    
58.     #设置语音播报语调 0-9,默认5
59.     def tone(self,tone):
60.         speed_buf = [0xfd,0x00,0x06,0x01,0x01,0x5b,0x74,0x30,0x5d]
61.         speed_buf[7] = (0x30 + tone)
62.         self.uart.write(bytes(speed_buf))   
64.     #播报警示音，index:1-5
65.     def play_alert(self,index):
66.         if index > 5:
67.             index = 5
68.         str = "alert_" + chr(0x30+index)
69.         self.set_code(0)
70.         self.play(bytes(str,'utf_8'))
71.         self.set_code(code_type)
73.     #播报信息提示音，index:1-5
74.     def play_msg(self,index):
75.         if index > 5:
76.             index = 5
77.         str = "message_" + chr(0x30+index)
78.         self.play(bytes(str,'utf_8'))
80.     #播报铃声，index:1-5
81.     def play_ring(self,index):
82.         if index > 5:
83.             index = 5
84.         str = "ring_" + chr(0x30+index)
85.         self.set_code(0)
86.         self.play(bytes(str,'utf_8'))
87.         self.set_code(code_type)
89.     #停止播报
90.     def stop(self):
91.         buf = [0xfd,0x00,0x01,0x02]
92.         self.uart.write(bytes(buf))  
94.     #暂停播报
95.     def pause(self):
96.         buf = [0xfd,0x00,0x01,0x03]
97.         self.uart.write(bytes(buf))         
99.     #继续播报
100.     def resume(self):
101.         buf = [0xfd,0x00,0x01,0x04]
102.         self.uart.write(bytes(buf))  
104.     def queryState(self):
105.         buf = [0xFD, 0x00, 0x02, 0x21, 0x00]
106.         self.uart.write(bytes(buf))
107.         response = self.uart.read()  # 返回bytes或None
108.         
109.         # 修正：先判断响应是否存在，再提取字节比较
110.         if response and len(response) > 0:
111.             resp_byte = response[0]  # 提取响应的第一个字节
112.             if resp_byte == 0x4E:
113.                 return TTS_STATE_PLAYING
114.             elif resp_byte == 0x4F:
115.                 return TTS_STATE_IDLE
116.             elif resp_byte == 0x4A:
117.                 return TTS_STATE_INIT
118.             elif resp_byte == 0x41:
119.                 return TTS_STATE_CHECK
120.         # 无有效响应返回错误状态
121.         return TTS_STATE_ERROR

复制代码

main.py

1. from machine import Pin
2. from machine import UART
3. from TW_TTS import TW_TTS, TTS_STATE_ERROR, TTS_STATE_PLAYING, TTS_STATE_IDLE, TTS_STATE_INIT, TTS_STATE_CHECK
4. from board import *
5. import network
6. import time
7. from machine import RTC
8. import ntptime
9. import urequests
10. import json
11. import ujson
13. my_wifi = wifi()
14. rtc = RTC()
15. def 时间校准():
16.     global tts_text, 今日风向, 今天夜晚天气现象, 今天白天天气现象, 最高气温, 最低气温, 日, 月, 年, 秒, 分, 时, 今日风速, 星期, daily_list, 后天最高气温, 后天最低气温, 明天最高气温, 明天最低气温, 后台天气现象, 明天天气现象, 今日湿度, results_list, location_list, text_dict, _response
17.     ntptime.settime(8,"ntp3.aliyun.com")
18.     年 = rtc.datetime()[0]
19.     月 = rtc.datetime()[1]
20.     日 = rtc.datetime()[2]
21.     星期 = rtc.datetime()[3]
22.     时 = rtc.datetime()[4]
23.     分 = rtc.datetime()[5]
24.     秒 = rtc.datetime()[6]
26. def 天气判断():
27.     global tts_text, 今日风向, 今天夜晚天气现象, 今天白天天气现象, 最高气温, 最低气温, 日, 月, 年, 秒, 分, 时, 今日风速, 星期, daily_list, 后天最高气温, 后天最低气温, 明天最高气温, 明天最低气温, 后台天气现象, 明天天气现象, 今日湿度, results_list, location_list, text_dict, _response
28.     print('获取温度，不同天气显示不同图案', end='')
29.     _response = urequests.get('http://www.haohaodada.com/project/weather/',headers={},timeout=10)
30.     text_dict = ujson.loads((_response.text))
31.     results_list = text_dict.get('results')
32.     location_list = results_list[0].get('location')
33.     daily_list = results_list[0].get('daily')
34.     最高气温 = str(daily_list[0].get('high'))
35.     最低气温 = str(daily_list[0].get('low'))
36.     今天白天天气现象 = str(daily_list[0].get('text_day'))
37.     今天夜晚天气现象 = str(daily_list[0].get('text_night'))
38.     今日风速 = str(daily_list[0].get('wind_scale'))
39.     今日风向 = str(daily_list[0].get('wind_direction'))
40.     今日湿度 = str(daily_list[0].get('humidity'))
41.     明天天气现象 = str(daily_list[1].get('text_day'))
42.     后台天气现象 = str(daily_list[2].get('text_day'))
43.     明天最低气温 = str(daily_list[1].get('low'))
44.     明天最高气温 = str(daily_list[1].get('high'))
45.     后天最低气温 = str(daily_list[2].get('low'))
46.     后天最高气温 = str(daily_list[2].get('high'))
48. syn=TW_TTS(0,1)
49. IO09 = BoardPin(9, PinMode.IN, pull=None)
50. my_wifi.connectWiFi('haoda7', '0123456789')
51. while not my_wifi.sta.isconnected():
52.     time.sleep_ms(1)
53. 时间校准()
54. 天气判断()
55. while True:
56.     时 = rtc.datetime()[4]
57.     分 = rtc.datetime()[5]
58.     秒 = rtc.datetime()[6]
59.     oled.fill(0)
60.     oled.DispChar(str((''.join([str(x) for x in [年, '年', 月, '/', 日]]))), 0, 0, 1)
61.     oled.DispChar(str((''.join([str(x2) for x2 in [时, '：', 分, '：', 秒]]))), 0, 16, 1)
62.     oled.DispChar(str((''.join([str(x3) for x3 in [最低气温, '℃ - ', 最高气温, '℃', '   ', 今天白天天气现象]]))), 0, 32, 1)
63.     oled.DispChar(str((''.join([str(x4) for x4 in [今日风向, '风   ', 今日风速, 'm/s']]))), 0, 48, 1)
64.     oled.show()
65.     if 时 == 0 and 分 == 0 and 秒 == 1:
66.         print('每日凌晨校准时间', end='')
67.         syn.set_code(0x04)
68.         syn.play(bytes('每日凌晨校准时间', 'utf-8'))
69.         时间校准()
70.     if 分 % 5 == 0 and 秒 == 0:
71.         print('每五分钟刷新一次天气', end='')
72.         syn.set_code(0x04)
73.         syn.play(bytes('每五分钟刷新一次天气', 'utf-8'))
74.         天气判断()
75.     if IO09.read_digital() == 0:
76.         time.sleep_ms(10)
77.         if IO09.read_digital() == 0:
78.             while IO09.read_digital() == 0:
79.                 pass
80.             tts_text = ''.join([str(x5) for x5 in ['今天是', 年, '年', 月, '月', 日, '日，', '最低气温', 最低气温, '摄氏度，', '最高气温', 最高气温, '摄氏度，', '今天白天', 今天白天天气现象, '，晚间', 今天夜晚天气现象, '，', 今日风向, '风']])
81.             syn.set_code(0x04)
82.             syn.play(bytes(tts_text, 'utf-8'))

复制代码

程序效果：

esp32WiFi连接，实时从网络获取天气数据，通过按键触发播放当前天气数据。

ASRPRO

电路连接：

ASRPRO的PA2（TX）引脚接TW_TTS的(R)引脚，ASRPRO的PA3（RX）引脚接TW_TTS的(T)引脚。

范例：ASRPRO控制语音合成播放指定文字

程序效果：

通过语音指令触发指定散文文本的 TTS 朗读，支持暂停 / 继续 / 停止等播放控制  。

STC8

电路连接：

本案例以P5_0为RX，P5_1为TX举例。P5_0与TW_TTS的T连接，P5_1与TW_TTS的R连接注意STC8的电源插脚接到5V，GND引脚互相连接。

范例： STC8串口控制播放语音

程序效果：

          语音合成模块上电播放：“初始化完成”，之后每两秒播放一次“好好搭搭”

米思齐esp32

电路连接：

范例： esp32串口控制播放语音

程序效果：

语音合成模块上电播放：“初始化完成”，语音合成空闲状态播放铃声1，之后每两秒播放一次“好好搭搭”

MIND+ arduino UNO

电路连接：

范例： arduino串口控制播放语音

程序效果：

上电初始化完成播放：“初始化完成”，模块结束播放状态则播放一段铃声，随后循环播放：“欢迎使用语音合成模块”

TW32F003

电路连接：

TW32的PA0（TX）引脚接TW_TTS的(R)引脚，TW32的PA1（RX）引脚接TW_TTS的(T)引脚。

范例：TW32F003控制语音合成播放指定文字

程序效果：

         上电初始化以后，语音合成会发出：“初始化完成”的语音提醒。语音合成当前状态会通过串口打印出来：

附录
TW_TTS.zip (14.14 MB, 下载次数: 108)

2026-1-12 11:43 上传

点击文件名下载附件

wxyh2023

不错  一如既往的支持天问！

makergeng

esp32的引脚1（TX0）连接TW_TTS的R引脚，可以正常工作。
esp32的引脚17（TX2）连接TW_TTS的R引脚，积木块选择Serial2，不工作。（即使选择Serial2，实际还是把数据从Serial0发出了）
请问积木块能否自定义 TX RX 引脚呢？

19959302505

makergeng 发表于 2026-1-18 20:14
esp32的引脚1（TX0）连接TW_TTS的R引脚，可以正常工作。
esp32的引脚17（TX2）连接TW_TTS的R引脚，积木块选 ...

我们的天问block平台图形话编程暂只支持esp32c3开发板，是可以自定义TX，RX引脚的

makergeng

希望增加Air001开发板的支持

一千个爱你的理由

我用STC 8怎样读变量的数字

shzhxz520

请问TTS支持arduinoide吗？支持ESP32-S3吗？