ESP32联网语音助手#

在做的项目需要一个联网语音部分，联网接入大模型或者其他的API，同时给OpenMV发信号，单独做出来好了（）。

ESP32回顾#

先来点个灯回顾一下ESP32的基础操作。Arduino IDE选ESP32 Dev Module。烧录一个点灯程序：

1
uint8_t led_pin = 2;
2

3
void setup()
4
{
5
    pinMode(led_pin, OUTPUT);
6
}
7

8
void loop()
9
{
10
    digitalWrite(led_pin, HIGH);
11
    delay(500);
12
    digitalWrite(led_pin, LOW);
13
    delay(500);
14
}

一. 语音模块#

例程#

选了语音模块是SYN6288。

烧录示例代码，烧录时不能接线，猜测是串口的原因。

1
void speech(){
2
  unsigned char i = 0;
3
  unsigned char head[56];
4

5
  head[0] = 0xFD;
6
  head[1] = 0x00;
7
  head[2] = 0x35;
8
  head[3] = 0x01;
9
  head[4] = 0x00;
10
  head[5] = 0x5B;
11
  head[6] = 0x6D;
12
  head[7] = 0x34;
13
  head[8] = 0x5D;
14
  head[9] = 0x5B;
15
  head[10] = 0x76;
16
  head[11] = 0x31;
17
  head[12] = 0x36;
18
  head[13] = 0x5D;
19
  head[14] = 0x5B;
20
  head[15] = 0x74;
21
  head[16] = 0x35;
22
  head[17] = 0x5D;
23
  head[18] = 0xBB;
24
  head[19] = 0xB6;
25
  head[20] = 0xD3;
26
  head[21] = 0xAD;
27
  head[22] = 0xCA;
28
  head[23] = 0xB9;
29
  head[24] = 0xD3;
30
  head[25] = 0xC3;
31
  head[26] = 0xC2;
32
  head[27] = 0xCC;
33
  head[28] = 0xC9;
34
  head[29] = 0xEE;
35
  head[30] = 0xC6;
36
  head[31] = 0xEC;
37
  head[32] = 0xBD;
38
  head[33] = 0xA2;
39
  head[34] = 0xB5;
40
  head[35] = 0xEA;
41
  head[36] = 0x53;
42
  head[37] = 0x59;
43
  head[38] = 0x4E;
44
  head[39] = 0x36;
45
  head[40] = 0x32;
46
  head[41] = 0x38;
47
  head[42] = 0x38;
48
  head[43] = 0xD3;
49
  head[44] = 0xEF;
50
  head[45] = 0xD2;
51
  head[46] = 0xF4;
52
  head[47] = 0xBA;
53
  head[48] = 0xCF;
54
  head[49] = 0xB3;
55
  head[50] = 0xC9;
56
  head[51] = 0xC4;
57
  head[52] = 0xA3;
58
  head[53] = 0xBF;
59
  head[54] = 0xE9;
60
  head[55] = 0x91;
61

62
  for(i=0; i<56; i++){
63
    Serial.write(head[i]);
64
  }
65
}
66

67

68
void setup() {
69
  Serial.begin(9600);
70
}
71

72
void loop() {
73
  speech();
74
  delay(10000);
75

76
}

烧录完后接线，就是正常的接VCC (3.3V)和GND，串口选用UART0的TX和RX。会有声音出来。

消息协议#

我希望实现一个输入文字能直接输出语音的效果，因此SYN6288模块例程还不够，需要解析一下这个协议是什么。

从文档的协议可以看出来，前三个字节可以不用管，第四个字节也不用管，在播放指令的时候命令字节都是0x01，第六个字节，因为我不加背景音乐，所以只关心最末3位，也就是格式控制位。在播放命令的时候，如果是GB2312格式的数据，就是0x00，测试了一下这个格式比较正常，或者GBK也可以，unicode有一点问题，我懒得解决了，就这样吧。

（arduino ide暂时没找到比较快的改编码格式方案，因此我选择gbk也就是说只能在vscode中写，ide只作为一个烧录工具。当然也可以选unicode格式，格式命令改成0x03就行。

接下来是数据内容。中文一个字符由2个字节表示。下面是一个传入字符串，输出消息格式的代码，测试了一下，和SYN6288厂商提供的上位机的转码是一样的。

1
#include "stdint.h"
2
#include "string.h"
3
#include "stdio.h"
4

5
void speech(char str[])
6
{
7
    static char data[256];
8
    static uint8_t len, str_len;
9

10
    data[0] = 0xFD; // 固定帧头
11
    data[3] = 0x01; // 播放指令
12
    data[4] = 0x00; // 格式gb2312
13
//    data[4] = 0x03; // 格式unicode
14

15
    str_len = strlen(str);
16
    memcpy(data + 5, str, str_len);
17

18
    data[1] = 0x00; // 数据长度
19
    data[2] = str_len + 3;
20

21
    len = str_len + 5;
22
    data[len] = 0;
23
    for (uint8_t i = 0; i < len; i++)
24
        data[len] ^= data[i];
25
    len++;
26

27
    for (uint8_t i = 0; i < len; i++)
28
        printf("0x%02X ", (uint8_t)data[i]);
29
}
30

31
int main()
32
{
33
    char str[] = "你好";
34
    speech(str);
35
    return 0;
36
}

语音实现#

然后可以开始写实际的代码了，大致如下，烧录时记得要把模块拔了。（这设计真有点有了了，看了下这个模块的VCC和GND还很容易接反。）

第一遍写的代码如下：

1
#include "stdint.h"
2
#include "string.h"
3

4
uint8_t led_pin = 2;
5

6
void setup()
7
{
8
    pinMode(led_pin, OUTPUT);
9
    Serial.begin(9600);
10
}
11

12
void speech(const char str[])
13
{
14
    static char data[256];
15
    static uint8_t len, str_len;
16

17
    data[0] = 0xFD; // 锟教讹拷帧头
18
    data[3] = 0x01; // 锟斤拷锟斤拷指锟斤拷
19
    data[4] = 0x00; // 锟斤拷式gb2312
20
                    //    data[4] = 0x03; // 锟斤拷式unicode
21

22
    str_len = strlen(str);
23
    memcpy(data + 5, str, str_len);
24

25
    data[1] = 0x00; // 锟斤拷锟捷筹拷锟斤拷
26
    data[2] = str_len + 3;
27

28
    len = str_len + 5;
29
    data[len] = 0;
30
    for (uint8_t i = 0; i < len; i++)
31
        data[len] ^= data[i];
32
    len++;
33

34
    for (uint8_t i = 0; i < len; i++)
35
        Serial.write(data[i]);
36
}
37

38
void loop()
39
{
40
    speech("你好！");
41
    digitalWrite(led_pin, HIGH);
42
    delay(1000);
43
    digitalWrite(led_pin, LOW);
44
    delay(1000);
45
}

状态查询#

但是很容易注意到，这模块在说话的时候又收到指令时，会停止当前说话，因此要要检查一下它话说完了吗。没有命令参数和数据内容，因此数据区长度直接就是2.

可以类似这样查询（下面这段代码没测试，因为有更好的方法）：

1
bool check_speaking(){
2
    static char data[256];
3
    static uint8_t len;
4

5
    data[0] = 0xFD; // Head
6
    data[1] = 0x00, data[2] = 0x02; // len
7
    data[3] = 0x21; // Check Speaking
8
    data[4] = 0xDE;
9
    len = 5;
10

11
    while (Serial.available() == 0);
12
    String receivedData = Serial.readString();
13
    if (receivedData[0] == 0x4F)
14
        return true;
15
    else
16
        return false;
17
}

但是一直进行串口通信肯定是不优的，我们还得分个中断来检查收到的内容。SYN6288支持硬件查询，也就是通过查询引脚BY的高低电平来判断。BY引脚是低电平的时候，说明空闲。

通过判断空闲来连续发送的代码如下：

1
#include "stdint.h"
2
#include "string.h"
3

4
uint8_t led_pin = 2;
5
uint8_t busy_pin = 12;
6

7
bool check_busy()
8
{
9
    return digitalRead(busy_pin);
10
}
11

12
void setup()
13
{
14
    pinMode(led_pin, OUTPUT);
15

16
    pinMode(busy_pin, INPUT);
17
    Serial.begin(9600);
18
}
19

20
void speech(const char str[])
21
{
22
    static char data[256];
23
    static uint8_t len, str_len;
24

25
    data[0] = 0xFD; // Head
26
    data[3] = 0x01; // Speak
27
    data[4] = 0x00; // gb2312
28
                    //    data[4] = 0x03; // unicode
29

30
    str_len = strlen(str);
31
    memcpy(data + 5, str, str_len);
32

33
    data[1] = 0x00;
34
    data[2] = str_len + 3;
35

36
    len = str_len + 5;
37
    data[len] = 0;
38
    for (uint8_t i = 0; i < len; i++)
39
        data[len] ^= data[i];
40
    len++;
41

42
    for (uint8_t i = 0; i < len; i++)
43
        Serial.write(data[i]);
44
}
45

46
void loop()
47
{
48
    if (check_busy() == false)
49
        speech("你好！");
50
    digitalWrite(led_pin, HIGH);
51
    delay(100);
52
    digitalWrite(led_pin, LOW);
53
    delay(100);
54
}

更换串口#

串口0一般我们是用来调试的，所以要更换到其他串口。我换到ESP32的第二个串口，也就是RX、TX分别为16、17。

代码和接线都改一下就行。

1
#include "stdint.h"
2
#include "string.h"
3

4
uint8_t led_pin = 2;
5
uint8_t busy_pin = 12;
6

7
HardwareSerial voice_serial(1);  // 定义串口
8

9
bool check_busy()
10
{
11
    return digitalRead(busy_pin);
12
}
13

14
void setup()
15
{
16
    pinMode(led_pin, OUTPUT);
17
    pinMode(busy_pin, INPUT);
18
    voice_serial.begin(9600, SERIAL_8N1, 16, 17);  // 初始化串口，波特率为9600，引脚16为TX，17为RX
19
}
20

21
void speech(const char str[])
22
{
23
    static char data[256];
24
    static uint8_t len, str_len;
25

26
    data[0] = 0xFD; // Head
27
    data[3] = 0x01; // Speak
28
    data[4] = 0x00; // gb2312
29
                    //    data[4] = 0x03; // unicode
30

31
    str_len = strlen(str);
32
    memcpy(data + 5, str, str_len);
33

34
    data[1] = 0x00;
35
    data[2] = str_len + 3;
36

37
    len = str_len + 5;
38
    data[len] = 0;
39
    for (uint8_t i = 0; i < len; i++)
40
        data[len] ^= data[i];
41
    len++;
42

43
    for (uint8_t i = 0; i < len; i++)
44
        voice_serial.write(data[i]);  // 使用新的串口发送数据
45
}
46

47
void loop()
48
{
49
    if (check_busy() == false)
50
        speech("你好！");
51
    digitalWrite(led_pin, HIGH);
52
    delay(100);
53
    digitalWrite(led_pin, LOW);
54
    delay(100);
55
}

模块封装#

接着把这玩意封装成c++的类，我个人感觉这样看着比较好看一点（）。特别是ESP32支持这个，就比其他只支持C的单片机更爽写ovo

1
#include "stdint.h"
2
#include "string.h"
3

4
class VoiceModule
5
{
6
private:
7
    HardwareSerial &voice_serial;
8
    uint8_t busy_pin;
9

10
public:
11
    // 构造函数，传入串口和busy引脚的序号
12
    VoiceModule(HardwareSerial &serial, uint8_t busy_pin)
13
        : voice_serial(serial), busy_pin(busy_pin) {}
14

15
    // 初始化函数，设置引脚模式和串口参数
16
    void begin(uint32_t baudRate, uint8_t txPin, uint8_t rxPin)
17
    {
18
        pinMode(busy_pin, INPUT);
19
        voice_serial.begin(baudRate, SERIAL_8N1, txPin, rxPin);
20
    }
21

22
    // 检查忙碌状态
23
    bool isBusy()
24
    {
25
        return digitalRead(busy_pin);
26
    }
27

28
    // 发送语音数据
29
    void speech(const char str[])
30
    {
31
        static char data[256];
32
        static uint8_t len, str_len;
33

34
        data[0] = 0xFD; // Head
35
        data[3] = 0x01; // Speak
36
        data[4] = 0x00; // gb2312
37
                        //    data[4] = 0x03; // unicode
38

39
        str_len = strlen(str);
40
        memcpy(data + 5, str, str_len);
41

42
        data[1] = 0x00;
43
        data[2] = str_len + 3;
44

45
        len = str_len + 5;
46
        data[len] = 0;
47
        for (uint8_t i = 0; i < len; i++)
48
            data[len] ^= data[i];
49
        len++;
50

51
        for (uint8_t i = 0; i < len; i++)
52
            voice_serial.write(data[i]);
53
    }
54
};
55

56
uint8_t led_pin = 2;
57

58
HardwareSerial voiceSerial(1);      // 定义串口实例
59
VoiceModule voice(voiceSerial, 12); // 创建语音模块实例，busy_pin为12
60

61
void setup()
62
{
63
    pinMode(led_pin, OUTPUT);
64
    voice.begin(9600, 16, 17); // 初始化语音模块，波特率为9600，引脚16为TX，17为RX
65
}
66

67
void loop()
68
{
69
    if (voice.isBusy() == false)
70
    {
71
        voice.speech("你好！");
72
    }
73
    digitalWrite(led_pin, HIGH);
74
    delay(100);
75
    digitalWrite(led_pin, LOW);
76
    delay(100);
77
}

二. 联网部分#

计划采用ESP32连接服务器，然后接大模型。那首先就要实现一个网络接口，能够实现传入一个中文字符串后，能发声。

这里我计划使用MQTT消息协议，选择的原因一个是比较好写，一个是快啊，而且好调试。

首先用我自己的MQTT服务器，确定两个东西：本地WIFI和服务器IP、MQTT框架运行的端口。

1
SSID = "foresp1"  # Network SSID
2
KEY = "20040724"  # Network key
3

4
MQTTClient("openmv", "113.45.173.169", port=1883)

MQTT服务器测试#

先自己写个python测试一下MQTT的收发是否正常，我把服务器和订阅的信息都存在和python同目录的config.yaml文件下，也就是：

1
server:
2
  address: "113.45.173.169"             # MQTT服务器地址
3
  port: 1883                            # MQTT服务器端口
4
  topics:                               # 可订阅主题
5
    - "openmv/voice"
6

7
client:
8
  name: "aicoach"                         # 监听客户端名称

发送的文件是sender.py，测试接收的文件是listener.py，这两个在不同的终端同时运行，就可以发送然后测试是否收到了。

1
'''
2
Author: wlaten
3
Date: 2024-07-05 20:49:29
4
LastEditTime: 2024-07-23 01:49:12
5
Discription: file content
6
'''
7
import os
8
import paho.mqtt.client as mqtt
9
import yaml
10

11
"""
12
listener.py
13
测试MQTT监听程序
14
"""
15

16
current_dir = os.path.dirname(os.path.abspath(__file__))
17
config_path = os.path.join(current_dir, 'config.yaml')
18

19
with open('config.yaml', 'r', encoding='utf-8') as file:
20
    config = yaml.safe_load(file)
21
MQTT_SERVER = config['server']['address']
22
MQTT_PORT = config['server']['port']
23
MQTT_TOPIC = config['server']['topics']
24

25
def on_message(client, userdata, msg):
26
    message = msg.payload.decode()
27
    topic = msg.topic
28
    print(f"Received message '{message}' on topic '{topic}'")
29

30

31
def on_connect(client, userdata, flags, rc):
32
    print("Connected with result code "+str(rc))
33
    for topic in MQTT_TOPIC:
34
        client.subscribe(topic)
35

36
if __name__ == '__main__':
37
    client = mqtt.Client()
38
    client.on_connect = on_connect
39
    client.on_message = on_message
40

41
    client.username_pw_set(config['client']['name'])
42
    client.connect(MQTT_SERVER, MQTT_PORT, 60)
43

44
    client.loop_forever()

1
"""
2
    sender.py
3
    模拟客户端，测试MQTT服务器收发消息
4
"""
5

6
import os
7
import paho.mqtt.client as mqtt
8
import yaml
9

10
# 获取当前脚本文件的绝对路径，然后获取同目录下的config.yaml文件的路径
11
current_dir = os.path.dirname(os.path.abspath(__file__))
12
config_path = os.path.join(current_dir, 'config.yaml')
13

14
with open(config_path, 'r', encoding='utf-8') as file:
15
    config = yaml.safe_load(file)
16
broker_address = config['server']['address']
17
broker_port = config['server']['port']
18

19
def on_connect(client, userdata, flags, rc):
20
    print(f"Connected with result code {rc}")
21

22
client = mqtt.Client()
23
client.on_connect = on_connect
24
client.connect(broker_address, broker_port, 60)
25

26
client.loop_start()
27

28
while True:
29
    topic = input("请输入主题: ")
30
    message = input("请输入消息内容: ")
31
    client.publish(topic, message)

测试了一下我的MQTT服务器运行正常，好可以开始写ESP32了。

ESP32连接MQTT#

先写一个ESP32连接WIFI的代码：

1
#include "stdint.h"
2
#include "string.h"
3
#include <WiFi.h>
4

5
#include "VoiceModule.h"    // 把前面的类封装进来
6

7
uint8_t led_pin = 2;
8

9
HardwareSerial voiceSerial(1);      // 定义串口实例
10
VoiceModule voice(voiceSerial, 12); // 创建语音模块实例，busy_pin为12
11

12
void network_init()
13
{
14
    const char *ssid = "foresp1";
15
    const char *password = "20040724";
16

17
    Serial.println();
18
    Serial.print("正在连接到 ");
19
    Serial.println(ssid);
20

21
    WiFi.begin(ssid, password);
22

23
    while (WiFi.status() != WL_CONNECTED)
24
    {
25
        delay(100);
26
        Serial.print(".");
27
    }
28

29
    Serial.println("");
30
    Serial.println("WiFi 已连接");
31
    Serial.println("IP 地址: ");
32
    Serial.println(WiFi.localIP());
33
}
34

35
void setup()
36
{
37
    Serial.begin(115200);  // 初始化调试串口
38
    Serial.println("Serial start...");
39

40
    network_init();      // 初始化网络
41

42
    pinMode(led_pin, OUTPUT);
43
    voice.begin(9600, 16, 17); // 初始化语音模块，波特率为9600，引脚16为TX，17为RX
44
}
45

46
void loop()
47
{
48
    if (voice.isBusy() == false)
49
    {
50
        voice.speech("你好！");
51
    }
52
    digitalWrite(led_pin, HIGH);
53
    delay(100);
54
    digitalWrite(led_pin, LOW);
55
    delay(100);
56
}

然后写连接MQTT服务器的代码。

1
const char *mqtt_server = "113.45.173.169";
2
const int mqtt_port = 1883;
3
const char *mqtt_user = "voice";
4
const char *mqtt_topic = "openmv/test";
5

6
WiFiClient espClient;
7
PubSubClient client(espClient);
8

9
void network_init()
10
{
11
    /* 初始化WIFI */
12
    const char *ssid = "foresp1";
13
    const char *password = "20040724";
14

15
    Serial.println();
16
    Serial.print("正在连接到 ");
17
    Serial.println(ssid);
18

19
    WiFi.begin(ssid, password);
20

21
    while (WiFi.status() != WL_CONNECTED)
22
    {
23
        delay(100);
24
        Serial.print(".");
25
    }
26

27
    Serial.println("");
28
    Serial.println("WiFi 已连接");
29
    Serial.println("IP 地址: ");
30
    Serial.println(WiFi.localIP());
31

32
    /* 初始化MQTT */
33
    client.setServer(mqtt_server, mqtt_port);
34
    //    client.setCallback(mqttCallback);
35
    Serial.println("MQTT连接中...");
36
    while (!client.connected())
37
    {
38
        if (client.connect(mqtt_user))
39
            break;
40
        else
41
        {
42
            delay(100);
43
            Serial.print(".");
44
        }
45
    }
46
}

现在在服务器上查询，可以看见已经连接成功了。

但是现在会发现，尽管连接成功了，但是过一会就会断开，这是因为没有发送心跳包保持连接，所以要在loop函数里面持续调用client.loop()。

或者为了进一步保持连接稳定，加入掉线重连接功能，完整代码：

1
#include "stdint.h"
2
#include "string.h"
3

4
#include <WiFi.h>
5
#include <PubSubClient.h>
6

7
#include "VoiceModule.h"
8

9
uint8_t led_pin = 2;
10

11
HardwareSerial voiceSerial(1);      // 定义串口实例
12
VoiceModule voice(voiceSerial, 12); // 创建语音模块实例，busy_pin为12
13

14
const char *mqtt_server = "113.45.173.169";
15
const int mqtt_port = 1883;
16
const char *mqtt_user = "voice";
17
const char *mqtt_topic = "openmv/test";
18

19
WiFiClient espClient;
20
PubSubClient client(espClient);
21

22
void mqtt_connect(){
23
    Serial.println("MQTT连接中...");
24
    while (!client.connected())
25
    {
26
        if (client.connect(mqtt_user))
27
            break;
28
        else
29
        {
30
            delay(100);
31
            Serial.print(".");
32
        }
33
    }
34
    Serial.println("MQTT已连接");
35
}
36

37
void network_init()
38
{
39
    /* 初始化WIFI */
40
    const char *ssid = "foresp1";
41
    const char *password = "20040724";
42

43
    Serial.println();
44
    Serial.print("正在连接到 ");
45
    Serial.println(ssid);
46

47
    WiFi.begin(ssid, password);
48

49
    while (WiFi.status() != WL_CONNECTED)
50
    {
51
        delay(100);
52
        Serial.print(".");
53
    }
54

55
    Serial.println("");
56
    Serial.println("WiFi 已连接");
57
    Serial.println("IP 地址: ");
58
    Serial.println(WiFi.localIP());
59

60
    /* 初始化MQTT */
61
    client.setServer(mqtt_server, mqtt_port);
62
    //    client.setCallback(mqttCallback);
63
    mqtt_connect();
64
}
65

66

67

68
void setup()
69
{
70
    Serial.begin(115200);
71
    Serial.println("Serial start...");
72
    network_init();
73

74
    pinMode(led_pin, OUTPUT);
75
    voice.begin(9600, 16, 17); // 初始化语音模块，波特率为9600，引脚16为TX，17为RX
76
}
77

78
void loop()
79
{
80
    client.loop();
81
    if (!client.connected())
82
        mqtt_connect();
83
    if (voice.isBusy() == false)
84
    {
85
        voice.speech("你好！");
86
    }
87
    digitalWrite(led_pin, HIGH);
88
    delay(100);
89
    digitalWrite(led_pin, LOW);
90
    delay(100);
91
}

ESP32发送MQTT消息#

尝试用ESP32发送一条消息到openmv/test这个主题上。只需要随便在哪里这样写一下就好：

1
  String message = "Hello from ESP32 你好！";
2
    client.publish("openmv/test", message.c_str());

这时候我们前面的python监听程序要改一下，因为监听默认是utf8格式。

1
def on_message(client, userdata, msg):
2
    try:
3
        message = msg.payload.decode('utf-8')  # 尝试用UTF-8解码
4
    except UnicodeDecodeError:
5
        message = msg.payload.decode('gbk')  # 如果失败，改用GBK解码
6
    topic = msg.topic
7
    print(f"Received message '{message}' on topic '{topic}'")

现在可以成功收到这样的消息了。

ESP32接收MQTT消息#

MQTT首先要订阅，然后接收。

首先确定订阅主题：

1
const char *mqtt_topics_sub[] = {
2
    "openmv/test",
3
    "openmv/voice",
4
    "sport_cmd"};
5
const int num_topics = sizeof(topics) / sizeof(topics[0]);

然后修改连接函数，在连接中订阅：

1
void mqtt_connect()
2
{
3
    Serial.println("MQTT连接中...");
4
    while (!client.connected())
5
    {
6
        if (client.connect(mqtt_user))
7
            break;
8
        else
9
        {
10
            delay(100);
11
            Serial.print(".");
12
        }
13
    }
14
    for (int i = 0; i < topics_sub_cnt; i++)
15
    {
16
        client.subscribe(topics[i]);
17
        Serial.print("Subscribed to topic: ");
18
        Serial.println(topics[i]);
19
    }
20
    Serial.println("MQTT已连接");
21
}

还需要设置回调函数：

1
client.setCallback(mqtt_callback);  // 加在network_init()里

1
void mqtt_callback(char *topic, byte *payload, unsigned int len)
2
{
3
    Serial.print("Message arrived on topic: ");
4
    Serial.print(topic);
5
    Serial.print(". Message: ");
6

7
    String messageTemp;
8

9
    for (int i = 0; i < len; i++)
10
        messageTemp += (char)payload[i];
11
    Serial.println(messageTemp);
12

13
    // 处理消息...
14
}

现在可以正常收发了，这里还需要修改sender.py文件来测试，保证发送是gbk格式。

1
while True:
2
    topic = input("请输入主题: ")
3
    message = input("请输入消息内容: ").encode('gbk')  // 编码gbk
4
    client.publish(topic, message)

可以发现现在是可以正常收发的。

现在整套代码基本实现了通过mqtt协议，网络传入中文字符串，语音模块发声。

1
#include "stdint.h"
2
#include "string.h"
3

4
#include <WiFi.h>
5
#include <PubSubClient.h>
6

7
#include "VoiceModule.h"
8

9
uint8_t led_pin = 2;
10

11
HardwareSerial voiceSerial(1);      // 定义串口实例
12
VoiceModule voice(voiceSerial, 12); // 创建语音模块实例，busy_pin为12
13

14
const char *mqtt_server = "113.45.173.169";
15
const int mqtt_port = 1883;
16
const char *mqtt_user = "voice";
17
const char *mqtt_topic = "openmv/test";
18

19
WiFiClient espClient;
20
PubSubClient client(espClient);
21

22
const char *mqtt_topics_sub[] = {
23
    "openmv/test",
24
    "openmv/voice",
25
    "sport_cmd"};
26
const int topics_sub_cnt = sizeof(mqtt_topics_sub) / sizeof(mqtt_topics_sub[0]);
27

28
void mqtt_connect()
29
{
30
    Serial.println("MQTT连接中...");
31
    while (!client.connected())
32
    {
33
        if (client.connect(mqtt_user))
34
            break;
35
        else
36
        {
37
            delay(100);
38
            Serial.print(".");
39
        }
40
    }
41
    for (int i = 0; i < topics_sub_cnt; i++)
42
    {
43
        client.subscribe(mqtt_topics_sub[i]);
44
        Serial.print("Subscribed to topic: ");
45
        Serial.println(mqtt_topics_sub[i]);
46
    }
47
    Serial.println("MQTT已连接");
48
}
49

50
void mqtt_callback(char *topic, byte *payload, unsigned int len)
51
{
52
    Serial.print("Message arrived on topic: ");
53
    Serial.print(topic);
54
    Serial.print(". Message: ");
55

56
    String rec;
57
    for (int i = 0; i < len; i++)
58
        rec += (char)payload[i];
59
    Serial.println(rec);
60

61
    if (strcmp(topic, "openmv/voice") == 0){
62
        if (voice.isBusy() == false)
63
            voice.speech(rec.c_str());
64
    }
65
}
66

67
void network_init()
68
{
69
    /* 初始化WIFI */
70
    const char *ssid = "foresp1";
71
    const char *password = "20040724";
72

73
    Serial.println();
74
    Serial.print("正在连接到 ");
75
    Serial.println(ssid);
76

77
    WiFi.begin(ssid, password);
78

79
    while (WiFi.status() != WL_CONNECTED)
80
    {
81
        delay(100);
82
        Serial.print(".");
83
    }
84

85
    Serial.println("");
86
    Serial.println("WiFi 已连接");
87
    Serial.println("IP 地址: ");
88
    Serial.println(WiFi.localIP());
89

90
    /* 初始化MQTT */
91
    client.setServer(mqtt_server, mqtt_port);
92
    client.setCallback(mqtt_callback);
93
    mqtt_connect();
94
}
95

96
void setup()
97
{
98
    Serial.begin(115200);
99
    Serial.println("Serial start...");
100
    network_init();
101

102
    pinMode(led_pin, OUTPUT);
103
    voice.begin(9600, 16, 17); // 初始化语音模块，波特率为9600，引脚16为TX，17为RX
104
}
105

106
void loop()
107
{
108
    client.loop();
109
    if (!client.connected())
110
        mqtt_connect();
111
    // if (voice.isBusy() == false)
112
    // {
113
    //     voice.speech("你好！");
114
    // }
115
    digitalWrite(led_pin, HIGH);
116
    delay(100);
117
    digitalWrite(led_pin, LOW);
118
    delay(100);
119
}

队列实现缓冲区#

可以发现还是有一个问题，就是因为这里我没有实现打断说话功能，因此正在说话时收到的消息就被丢弃了。

可以用一个queue实现缓冲区（c++真爽写吧，换其他只支持c的单片机就要写好多）。此外，针对字节上限，也要做一个分割。

1
#include "stdint.h"
2
#include "string.h"
3

4
#include "queue"
5
using namespace std;
6

7
#include <WiFi.h>
8
#include <PubSubClient.h>
9

10
#include "VoiceModule.h"
11

12
uint8_t led_pin = 2;
13

14
HardwareSerial voiceSerial(1);      // 定义串口实例
15
VoiceModule voice(voiceSerial, 12); // 创建语音模块实例，busy_pin为12
16

17
const char *mqtt_server = "113.45.173.169";
18
const int mqtt_port = 1883;
19
const char *mqtt_user = "voice";
20
const char *mqtt_topic = "openmv/test";
21

22
WiFiClient espClient;
23
PubSubClient client(espClient);
24

25
const char *mqtt_topics_sub[] = {
26
    "openmv/test",
27
    "openmv/voice",
28
    "sport_cmd"};
29
const int topics_sub_cnt = sizeof(mqtt_topics_sub) / sizeof(mqtt_topics_sub[0]);
30

31
queue<String> voice_queue;  // 语音队列
32

33
void mqtt_connect()
34
{
35
    Serial.println("MQTT连接中...");
36
    while (!client.connected())
37
    {
38
        if (client.connect(mqtt_user))
39
            break;
40
        else
41
        {
42
            delay(100);
43
            Serial.print(".");
44
        }
45
    }
46
    for (int i = 0; i < topics_sub_cnt; i++)
47
    {
48
        client.subscribe(mqtt_topics_sub[i]);
49
        Serial.print("Subscribed to topic: ");
50
        Serial.println(mqtt_topics_sub[i]);
51
    }
52
    Serial.println("MQTT已连接");
53
}
54

55
void mqtt_callback(char *topic, byte *payload, unsigned int len)
56
{
57
    Serial.print("Message arrived on topic: ");
58
    Serial.print(topic);
59
    Serial.print(". Message: ");
60

61
    String rec;
62
    for (int i = 0; i < len; i++)
63
        rec += (char)payload[i];
64
    Serial.println(rec);
65

66
    if (strcmp(topic, "openmv/voice") == 0)
67
        voice_queue.push(rec);
68
}
69

70
void network_init()
71
{
72
    /* 初始化WIFI */
73
    const char *ssid = "foresp1";
74
    const char *password = "20040724";
75

76
    Serial.println();
77
    Serial.print("正在连接到 ");
78
    Serial.println(ssid);
79

80
    WiFi.begin(ssid, password);
81

82
    while (WiFi.status() != WL_CONNECTED)
83
    {
84
        delay(100);
85
        Serial.print(".");
86
    }
87

88
    Serial.println("");
89
    Serial.println("WiFi 已连接");
90
    Serial.println("IP 地址: ");
91
    Serial.println(WiFi.localIP());
92

93
    /* 初始化MQTT */
94
    client.setServer(mqtt_server, mqtt_port);
95
    client.setCallback(mqtt_callback);
96
    mqtt_connect();
97
}
98

99
void setup()
100
{
101
    Serial.begin(115200);
102
    Serial.println("Serial start...");
103
    network_init();
104

105
    pinMode(led_pin, OUTPUT);
106
    voice.begin(9600, 16, 17); // 初始化语音模块，波特率为9600，引脚16为TX，17为RX
107
}
108

109
void loop()
110
{
111
    client.loop();
112
    if (!client.connected())
113
        mqtt_connect();
114
    if (voice.isBusy() == false)
115
    {
116
        if (!voice_queue.empty())
117
        {
118
            voice.speech(voice_queue.front().c_str());
119
            voice_queue.pop();
120
        }
121
    }
122
    digitalWrite(led_pin, HIGH);
123
    delay(100);
124
    digitalWrite(led_pin, LOW);
125
    delay(100);
126
}