【ESP32】制作 Wi-fi 音箱(HTTP + I2S 协议)

用 Wifi 来传输音频数据,会比蓝牙更好。使用蓝牙方式,不管你用什么协议,都会对数据重新编码,说人话就是有损音质,虽然不至于全损。而使用 Wifi 就可以将 PCM 数据直接传输,无需再编码和压缩。在 ESP32 开发板上可以通过 I2S(IIS)向功放芯片发出音频数据。

关于 i2s 的时序,老周就不啰嗦了,这种玩意儿,网上一搜一大把,老周写东西向来不喜欢抄的,所以,时序相关的就省略了。不过,有一点老周要说清楚:i2s 传输的是数字信号,不是模拟信号。这一点一定得记住,千万不要把 i2s 直接连接喇叭,没鸟用的。它要先给功放处理,放大后输出模拟信号,才能连接喇叭。所以说,i2s 是数字芯片之间通信用的。本质来说,也是 IO 接口的电平高低的变化,所以,i2s 不仅可以传输数字音频,还可以驱动 WS2812 彩灯。这种 RGB 彩灯也真是博大包容,几乎啥协议它们都受用。

先简单老周自己做的个人 WiFi 音响,功放芯片用的是 NS4168,对,M5Stack Atom Echo 开发套件用的就是这个芯片,这货虽然体积小巧,但是喇叭配得不怎么行,声音又尖又刺,还伴随严重的谐振,所以不要拿它来播放太嗨的电子舞曲(官方文档也说了,不要长时间播放重低音,嗯,他们还算有点自知之明)。老周用的是 3W/4Ω 扬声器,是从一台某科 DVD 机上拆下来的。前面用过 MaxXXXX 系列的芯片,发现杂音特严重,就跟二战时期的电报音差不多。

至于传输,这个就没限制,就是常规的网络通信。用 TCP、UDP、MTQQ(这个不太适合)都行,老周用的是 HTTP。音频不可能保存在 ESP 的 Flash 上的,不然就不叫 Wi Fi 音响了。在服务器上,老周用 ASP.NET Core 实现,做了三个页面:简单的密码验证(主要防熊孩子)、PCM 音频上传页,以及自定义播放列表页。播放列表是事先定义好,存放在 JSON 文件中。当我按一下连接到 ESP32 的按钮,就会向服务器发出请求,开始播放列表中的歌曲。

ESP 32 上面(客户端)本来计划用 .NET Nano Framework 来搞的,毕竟这个兼得了 .NET 的高效编程方式,同时性能也不太差。但很可惜,老周连试了三块开发板都不行。面向 Esp 32-Pico 的 Nano CLR 固件不带 i2s 本地代码,无法用;刷其他版本的固件无法启动 CLR。另一块 Esp32-S3 因为是高度封装版,没有引出太多的 IO,也干不了。然后,老周翻出尘封多年,当初 78 元买入,现在涨了四倍价格的乐鑫 LyraT 开发板。经测试还是不行。然后,又用某果云定制的 ESP32 板子测试,依然不行。

那玩不下了吗?不,千好万好还是原生 SDK 好,那就用 esp-idf 来弄吧。至于 .NET Nano 的,下次老周买一块 esp32-s3 的核心板再试。

 -------------------------------------------------------------------------------------------

WTF,不知不觉居然讲了那么F话,下面咱们开始。.NET 服务器端很好弄,所以留在后面说,先说 IDF 的。ESP32 最让人喜欢的就是有 Wifi,有蓝牙,还集成各种玩意儿,确实是性价比之王。但,乐鑫自己做的开发板就特别贵,当然做工会比20多元的好。esp32 客户端咱们要完成这几件事:

1、初始化网络接口。不管是用 Wifi-STA,Wifi-AP,或是用带以太网接口的,都要初始化 netif(Net Interface);

2、初始化 Wifi。这里咱们是要连接到路由器,然后访问服务器上的音频。故,很明显,是要选择 STA 模式(Station);

3、初始化 i2s 驱动(5.x 的 idf 是分开发送和接收通道的,发送是播放,接收是录音,比如麦克风);

4、初始化 HTTP 客户端参数;

5、发起 HTTP 请求。

 

一、初始化 Wifi

Wifi 的初始化过程是这样的:

A、调用 esp_netif_init 函数(esp_netif.h),这是初始化所有网络接口的驱动,并不只是无线网。

B、调用 esp_netif_create_default_wifi_sta 函数(esp_wifi_default.h)。这个函数会用默认的配置初始化 Wifi 驱动,并创建表示网络接口的 esp_netif_t,类型当然是指针的。我们用的是STA模式,所以……,如果是AP模式,可以调用 esp_netif_create_default_wifi_ap 函数。其实,C语言的指针不是你想的那么恐怖,只是很多教程压根没告诉你指针怎么用。因为返回的这个 esp_netif_t 对象,后面在调用其他函数时会用到,也就是说在其他地方要引用这个对象,所以你想想,用什么合适?那当然是指针了。毕竟大伙都知道,指针是保存地址的,正因为这样,才能保存你把它传给其他代码后,它引用的仍然是同一个对象。直接用类型声明的话,你在传递时它会自我复制,这会导致其他代码引用的不是这个对象了,而是复制体。

另外,不要看到指针类型就以为一定是堆上分配内存,看到一般变量声明就说是栈分配内存。指针类型与堆分配并没什么关系,它只是保存某对象的内存地址罢了,如果你代码这样写,那么,指针类型也可以保存栈内存的地址:

int x;
x = 999;
int* px = &x;     /* 存入了x的地址,x是栈上分配的 */

堆分配是用 new 关键字,或 malloc 函数,或 calloc 函数分配的,在不需要时可以 delete 或 free。堆上分配的是动态的内存空间,所以得到的肯定是指针类型的值,因为有了指针,就有其地址,就能访问。所以,很多有良好编码习惯的人,都会在 delete / free 之后,把指针类型的变量设置为 NULL:px = NULL。

这啥呢,虽然你把那片内存毙了,但指针变量里还是存着那个地址,此时它指向的是那片被清理了的内存。那里很乱的,所以人们也叫它“脏内存”,里面全是些没用的随机字节,污染严重,故很脏。

esp_netif_create_default_wifi_ap 或 esp_netif_create_default_wifi_sta 函数实际上调用了宏—— ESP_NETIF_DEFAULT_WIFI_AP、ESP_NETIF_DEFAULT_WIFI_STA,用默认的值配置后,用 esp_netif_new 函数创建 esp_netif_t;然后调用 esp_netif_attach_wifi_station 或 esp_netif_attach_wifi_ap 函数,把驱动关联到接口。最后用 esp_wifi_set_default_wifi_ap_handlers 或 esp_wifi_set_default_wifi_sta_handlers 注册默认的事件回调用函数。

ESP 的事件由两个值来描述:1、esp_event_base_t 类型的是事件基础值,可以理解为一组事件中的组标识。比如,咱们 Wifi 相关的事件,其 event base 就是 WIFI_EVENT;2、事件 ID,指代具体的事件,比如,属于 WIFI_EVENT 下的事件有:

WIFI_EVENT_STA_START:STA模式已启动;

WIFI_EVENT_AP_START:AP模式已启动;(AP模式,就是 wifi 热点,你可以理解为 esp32 当作路由器来用,其他机器连接到 esp32)

WIFI_EVENT_STA_CONNECTED:esp32 成功连上 Wifi 后发生;

WIFI_EVENT_STA_DISCONNECTED:掉线后发生,此时可以重新连接。

……

C、调用 esp_netif_set_hostname 函数为 esp32 板子设置主机名。这一步是可选的,如果不设置,默认是“espressif”;

D、调用 esp_wifi_init 函数初始化 Wifi;

E、调用 esp_wifi_set_config 函数配置 Wifi。如你路由器的 SSID,密码等。它的参数是内联类型——即共享内存的类型。说简单的就是 STA 模式和 AP 模式的配置信息占用相同的内存。

typedef union {
    wifi_ap_config_t  ap;  /**< configuration of AP */
    wifi_sta_config_t sta; /**< configuration of STA */
    wifi_nan_config_t nan; /**< configuration of NAN */
} wifi_config_t;

当你用的是STA模式,就配置 sta 成员,类型是 wifi_sta_config_t 结构体;同理,用AP模式时只配置 ap 成员就可以了;用 NAN 模式时,只配置 nan 成员。nan 也是个好用的东西,Network Awareness,网络感知。它是端对端联机,就是你不用连接路由器,不用上网,而是网卡之间直接可以连接,esp32 板子之间可以直接通信。

F、一切就绪,调用 esp_wifi_start 启动 Wifi。这时,esp 会自动连接路由器,连接成功后会发生 WIFI_EVENT_STA_CONNECTED 事件。

 

二、初始化 I2S

A、调用 i2s_new_channel 函数创建 I2S 通道,包括发送(TX)和接收(RX)通道。创建的通道用 i2s_chan_handle_t 表示。如果只用发送(播放音乐,不录音)不用接收,调用函数时,接收通道可以传递 NULL。

B、通道创建后,还无法使用,还要初始化它。因为 I2S 用发送和接收两个方向,有 PDM、STD、TDM 等模式。PDM一般是麦克风用,播放音频需要用 STD(标准模式)。为了方便配置,IDF 也提供了一组宏,可以直接用,只要指定采样率(Hz)即可,其他参数保持默认。如 I2S_STD_CLK_DEFAULT_CONFIG 宏可直接配置标准 I2S。配置参数传给 i2s_channel_init_std_mode 函数进行初始化。

C、调用 i2s_channel_enable 函数启用通道。如果不传输数据了,也可以调用 i2s_channel_disable 函数禁用通道。

D、此时,可以向功放芯片发送数据了。发送数据调用 i2s_channel_write 函数,接收数据调用 i2s_channel_read 函数。

E、不再使用 I2S 时可以调用 i2s_del_channel 函数删除通道,释放驱动。

 

三、初始化 HTTP 客户端

 A、用 esp_http_client_config_t 结构体初始化 HTTP 客户端,如请求的 URL,请求方式(GET、POST 等),随后用 esp_http_client_init 函数初始化,会返回 esp_http_client_handle_t 类型的句柄,它就是个符号,后面调用的 HTTP 有关的函数需要用到它。

B、esp_http_client_open 函数打开连接;

C、esp_http_client_write 函数向服务器发数据。POST 的时候需要,GET 的时候不需要,可以不调用。

D、esp_http_client_fetch_headers 函数获取服务器响应的 HTTP 头。注意,获取的是消息头,不是正文。

E、esp_http_client_read 函数读数据。这时候读的才是 HTTP 正文(Body)。

F、esp_http_client_close 函数,调用它关闭连接。

G、如果不再发出 HTTP 请求了可以调用 esp_http_client_cleanup 清理资源;如果后面还要向服务器发请求,那先不要调用。

从步聚B到F,其实可以用一个 esp_http_client_perform 函数一步到位。它会自动调用 从open,到 fetch,到 write、read,到 close 等方法。

不过,咱们这里向服务器请求的是 PCM 音频流,数据较长,不能一次就读完,咱们要读一点,然后发到 I2S 播放,然后再读后面的。所以就不能用 esp_http_client_perform 函数了。

 

-----------------------------------------------------------------------------------------------------------------

有了上面的流程印象,接下来咱们编码就好弄很多了。其实 C 语言没有你想的那么复杂,应该说复杂的是 C++。某些编程语言,如 Rust 拼命宣传自己这样那样比C语言好,而实际上根本不是。Rust 在设计上出发点就是错的,反人类语法多,还加入了各种莫名其妙的东西。想想那么多硬件设备程序都是用汇编、C语言写的,也不见得人家那么多故障。更多时候,无操作系统裸机跑的程序才是最稳定,或者用一些内核简单的系统做复杂任务调度(如 esp 用的 RTOS)。设备一旦有了操作系统,问题就多起来。

1、编写 init_i2s 函数,初始化 i2s 接口。

// I2S通道句柄
static i2s_chan_handle_t iis_tx_ch;

static void init_i2s()
{
    // 1、创建通道
    i2s_chan_config_t chcfg = I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_0, I2S_ROLE_MASTER);
    ESP_ERROR_CHECK(i2s_new_channel(&chcfg, &iis_tx_ch, NULL));
    // 2、配置通道
    i2s_std_config_t stdcfg = {
        // 时钟源,调用默认宏设置就行了
        .clk_cfg = I2S_STD_CLK_DEFAULT_CONFIG(SAMPLE_RATE),
        // slot其实就是声道数
        .slot_cfg = I2S_STD_PCM_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_STEREO),
        // 下面配置IO引脚号
        .gpio_cfg = {
            .dout = I2S_DATA,    // 数据线
            .bclk = I2S_BIT_CLK, // 位时钟线
            .ws = I2S_LR_CLK,    // 左右声道选择线
            // 下面这几个是说,引脚电平是否反转,通常不要反转,否则信号全错了
            .invert_flags = {
                .mclk_inv = false,
                .bclk_inv = false,
                .ws_inv = false}}};
    // 初始化函数
    ESP_ERROR_CHECK(i2s_channel_init_std_mode(iis_tx_ch, &stdcfg));
    // 3、使能通道,不然通不了
    ESP_ERROR_CHECK(i2s_channel_enable(iis_tx_ch));
}

i2s_chan_handle_t 类型的变量要声明为全局变量,因为待会儿在读取 HTTP 流并发送数据时要用到。

i2s_chan_config_t 对象咱们不必自己设置,用 I2S_CHANNEL_DEFAULT_CONFIG 宏就行了。

I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_0, I2S_ROLE_MASTER)

i2s_new_channel 后两个参数分别是发送和接收通道的句柄,但这里咱们不用接收,所以直接给它 NULL。

I2S_NUM_0 指的是 i2s 总线号,ESP32 通常有两路 i2s 可用,第一路就是0,如果是 I2S_NUM_1 就表示选择用第二路。注意,这个只是逻辑上的总线号,不绑定硬件的,所以,IO脚编号你可以选不同组合。I2S_ROLE_MASTER 表示主机模式,因为是开发板发音频数据给功放芯片的,所以开发板当然是主机了。如果开发板作为从机,比如 esp 成为功放设备,电脑向 esp 发数据,那可以选从机角色(I2S_ROLE_SLAVE)。

主机和从机角色有啥不同呢?咱们先了解一下 IIS 的引脚就知道了。

1、MCLK:主时钟源,这个现在 99.996% 的芯片是不用连接的。这个是在功放芯片自己没有时钟源时才需要(比如无振荡器),没有时钟就不能产生电平高低变化了,那还通信个妖。

2、LRCLK:选择左右声道用的。就是上面代码 gpio_cfg 的 ws 成员,叫法不一样罢了。

3、BCLK:位时钟线,就是每个跳变周期你得发送/接收一个二进制位,这个好懂吧,就跟 i2c 的 SCL 差不多。

4、DATA:可能一根线,可能两根线(输入/输出)。就是传数据用的。

当你的 I2S 是主机时,LRCLK、BCLK 等时钟线是输出状态,时钟快慢,电平高低由你来决定,你是西楚霸王你说了算。当 I2S 是从机时,这些时钟线是输入状态,你必须听从别人的命令干活,人家发一个时钟周期你就要传一个二进制位。电平高低是别人说了算

此处咱们是向功放发数据,所以数据线只配置 dout 就行了。引脚编号基本可以随便选。

i2s_std_config_t 的 clk_cfg 成员是配置时钟源,用 I2S_STD_CLK_DEFAULT_CONFIG 宏设置默认的就行,免得自己配置错了还要计算分频。参数是采样率,如 44100 Hz。

slot_cfg 成员其实指的是声道,同理,用 I2S_STD_PCM_SLOT_DEFAULT_CONFIG 宏解决。因为咱这里是用 PCM 数据,所以要用针对 PCM 的配置,参数是位宽和声道数。当然,如果用飞利浦标准的话,就用 I2S_STD_PHILIPS_SLOT_DEFAULT_CONFIG 宏。常见的无损音频多是 16 位,这也是CD的标准;第二个参数 I2S_SLOT_MODE_STEREO 表示立体声(不是单纯的左右双声通道,而是有混合的);如果想用单声道,可以取值 I2S_SLOT_MODE_MONO。

注意,初始化通道后记得调用 i2s_channel_enable 函数启用通道,这一步容易忘记

 -------------------------------------------------------------------------------------------------------------------------

编写 init_wifi 函数,初始化 Wifi。既然要无线传输了,当然得连路由器啦。这个过程一般配合事件队列来弄,可以在不同条件下触发不同的行为。当然了,你嫌麻烦也可以不用事件的,在启动 Wifi STA 后 delay 200 毫秒,在连接 Wifi 时 delay 3 秒。用延时等待的方式也不是不行,只是要等多久不太好确定,控制不够精准,所以还是用事件的好。

按流程走就不会错,连 Wifi 的流程时:接口初始化(加载驱动)--> WIFI 初始化--> 配置 STA-->启动WIFI-->连接WIFI。

static void init_wifi()
{
    // 1、初始化网络接口
    esp_netif_init();
    // 2、加载无线网络接口
    esp_netif_t *interface = esp_netif_create_default_wifi_sta();
    // 设置主机名(可选)
    esp_netif_set_hostname(interface, "WaWaZ");
    // 3、初始化wifi
    wifi_init_config_t wfcfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&wfcfg));
    // 这个可选
    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
    // 4、配置STA模式
    wifi_config_t cfg =
        {
            .sta = {
                .ssid = MY_SSID,
                .password = MY_PWD,
                .bssid_set = false,
                .threshold.authmode = WIFI_AUTH_WPA_WPA2_PSK}};
    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &cfg));
    // 设置wifi密码保存在Flash上(nvs分区)
    esp_wifi_set_storage(WIFI_STORAGE_FLASH);
    // 启动wifi
    ESP_ERROR_CHECK(esp_wifi_start());
}

顺便补充一点,返回 esp_error_t 类型的函数都可以把返回传给 ESP_ERROR_CHECK 宏,这个宏是当有错误时输出在哪个代码文件哪一行,帮助你找到错误。

esp_netif_init 函数必须在所有网络相关的初始化之前调用。也就是说,不管你用无线还是有线(有些板子有以太网口),只要是和网络有关的,你都要先调用它。esp_netif_create_default_wifi_sta 是为STA模式的无线网络接口分配资源(加载驱动等),返回 esp_netif_t 实例,引用它可以调用其他相关函数。

esp_wifi_init 函数初始化的是接口层面上的配置,不是用来设置 SSID、连接密码的。一般用 WIFI_INIT_CONFIG_DEFAULT 宏获取默认值就可以了。这个是设置硬件参数的,自己设置如果弄不好,可能连接不了网络。甚至包括加解密的算法,除非你的路由器是自己做的,加密算法是自己写的,否则你不需要更改默认配置。

esp_wifi_set_config 函数才是用来设置 SSID、连接密码的,使用 wifi_config_t 结构体来配置。咱们这里用的是 STA 模式,所以只配置 sta 成员就好了。STA 模式下要把 bssid_set 成员设置为 false。ssid和 password 成员就不用介绍,字面意思都能知道是啥玩意。threshold.authmode 是指定路由器的加密措施,可以看路由器配置,也可以逐个试。常见是 WIFI_AUTH_WPA_WPA2_PSK 、WIFI_AUTH_WPA2_PSK。

esp_wifi_set_storage 函数是设置 wifi 配置的保存地方,就是你设置的 SSID、密码保存在哪,这样下次连 Wifi 时不用再设置了。配网的时候就经常这样弄。不过老周这里是直接把 SSID 硬编码了,为了简单。此处指定 WIFI_STORAGE_FLASH 就是把配置存到 Flash上。你看看 esp 的分区表,是不是有个叫 nvs 的。对,这个分区就是用来存放配置的,以字典(key / value)方式读写数据。正因为要用到 nvs 分区,所以在初始化 wifi 前,就要初始化 nvs,这个咱们把代码放到 app_main 函数里写。

esp_wifi_start 函数调用完毕后,如果不出事故,wifi 已经可用了。连接 WIFI 调用 esp_wifi_connect 函数,断开 Wifi 调用 esp_wifi_disconnect 函数。不过,前面说了,咱们既然用到事件队列,连接 Wifi 的操作自然要放在事件回调函数中。

static void network_event_cb(
    void *ev_arg,
    esp_event_base_t evtbase,
    int32_t evt_id,
    void *evt_data)
{
    if (evtbase == WIFI_EVENT)
    {
        switch (evt_id)
        {
        case WIFI_EVENT_STA_CONNECTED:
            // 连接成功,发送一个事件位标志
            xEventGroupSetBits(evt_grp_hd, EVG_WIFI_CONNECTED_BIT);
            break;
        case WIFI_EVENT_STA_DISCONNECTED:
            // 断线了自动连接
            esp_wifi_connect();
            break;
        case WIFI_EVENT_STA_START:
            // STA 模式启动了,连接路由器
            esp_wifi_connect();
            break;
        default:
            break;
        }
    }

    if (evtbase == IP_EVENT)
    {
        // 获取到IP地址
        if (evt_id == IP_EVENT_STA_GOT_IP)
        {
            // 发送一个事件位标志
            xEventGroupSetBits(evt_grp_hd, EVG_NETIF_GOTIP_BIT);
        }
    }
}

事件回调用函数的声明是这样的:

void         (*esp_event_handler_t)(void* event_handler_arg,
                                        esp_event_base_t event_base,
                                        int32_t event_id,
                                        void* event_data);

没错,这货是一个函数指针,event_handler_arg 参数是指向 void 的指针,在注册事件回调时由你自己指定,等于是一个上下文对象,不用的话,直接给 NULL 就行;event_base 就是事件基础标识,前面介绍过,你可以认为它是一个事件发组的标识,这里用到 WIFI_EVENT,表明我后面处理的事件是和 Wifi 有关的;event_data 是事件相关的数据,不同事件的数据不同,所以它的类型是 void 指针。vadw oid 可以表示万能类型。

例如,WIFI_EVENT_STA_CONNECTED 事件表示 Wifi 连接成功,它对应的事件数据是 wifi_event_sta_connected_t。包括 SSID,连接使用的频道等信息。

注册事件在 app_main 函数中完成,待会再扯,下面看HTTP客户端初始化。写到一个函数里面,在app_main中会创建一个新任务,让它在新任务上运行。

static void http_req_task(void *arg)
{
    esp_http_client_config_t cfg =
        {
            .url = HTTP_SERVER_ADDR,
            .buffer_size = 89120,
            .method = HTTP_METHOD_GET};
    esp_http_client_handle_t httpHandle;
    // 初始化客户端
    httpHandle = esp_http_client_init(&cfg);
    // 缓冲区
    const uint16_t bufSize = 98000;
    uint8_t *buffer = (uint8_t *)malloc(bufSize);
    memset(buffer, 0, bufSize);
    while (1)
    {
        // 1、打开连接
        err_t res = esp_http_client_open(httpHandle, 0);
        if (res != ESP_OK)
        {
            vTaskDelay(pdMS_TO_TICKS(5000));
            continue;
        }
        // 2、获取流大小
        int64_t contentLen = esp_http_client_fetch_headers(httpHandle);
        if (contentLen <= 0)
        {
            vTaskDelay(pdMS_TO_TICKS(5000));
            continue;
        }
        // 3、读取内容
        int readLen = 0;
        readLen = esp_http_client_read(httpHandle, (char *)buffer, bufSize);
        // 4、把数据发送到 i2s
        while (readLen > 0)
        {
            i2s_channel_write(iis_tx_ch, (void *)buffer, readLen, NULL, 100);
            // 继续读
            readLen = esp_http_client_read(httpHandle, (char *)buffer, bufSize);
        }
        // 5、关闭连接
        esp_http_client_close(httpHandle);
        vTaskDelay(pdMS_TO_TICKS(2000));
    }
    // 清理
    free(buffer);
}

HTTP 是协议层的,初始化时不用加载硬件驱动,所以它的仪式感就没那么强了。esp_http_client_config_t 结构体用于配置 HTTP 请求相关的信息。url 成员指定你要请求的URL,buffer_size 是esp处理传输数据的缓冲大小,不是你写代码时用的字节数组的大小。method 成员指定请求方式,如 GET、POST 等。

调用 esp_http_client_init 函数后,返回 esp_http_client_handle_t 句柄,后面调用其他 HTTP 函数时用得到。这样就完工了,然后就是通信了。此处由于要使用流操作,不使用 esp_http_client_perform 函数,而是分步完成。esp_http_client_fetch_headers 函数读取服务器响应的 HTTP 头,并且该函数返回的值就是 Content-Length。这样咱们就知道音频 PCM 有多大了。

剩下的就是不断用 esp_http_client_read 从流中读数据,再用 i2s_channel_write 函数发数据。在上述代码中,代码写在一个死循环中,所以,会向同一 URL 不断发出请求,单曲循环(当然了,服务器可以选择返回不同的曲子)。

 

最后就是主任务—— app_main 函数了。

void app_main(void)
{
    // 初始化nvs存储
    err_t res = nvs_flash_init();
    if (res != ESP_OK)
    {
        // 不管你大爷是什么原因导致初始化失败
        // 一律格(杀)式(勿)化(论)
        nvs_flash_erase();
        // 再试一次
        res = nvs_flash_init();
    }
    if (res != ESP_OK)
    {
        ESP_LOGI("nvs", "真的无法初始化NVS了,请自我检讨");
        return;
    }
    /*------------------------------------------------------------------------*/
    // 创建默认的事件队列
    ESP_ERROR_CHECK(esp_event_loop_create_default());
    // 创建事件组
    evt_grp_hd = xEventGroupCreate();
    // 注册事件
    ESP_ERROR_CHECK(esp_event_handler_register(
        WIFI_EVENT,
        WIFI_EVENT_STA_START,
        network_event_cb,
        NULL));
    ESP_ERROR_CHECK(esp_event_handler_register(
        WIFI_EVENT,
        WIFI_EVENT_STA_CONNECTED,
        network_event_cb,
        NULL));
    ESP_ERROR_CHECK(esp_event_handler_register(
        WIFI_EVENT,
        WIFI_EVENT_STA_DISCONNECTED,
        network_event_cb,
        NULL));
    ESP_ERROR_CHECK(esp_event_handler_register(
        IP_EVENT,
        IP_EVENT_STA_GOT_IP,
        network_event_cb,
        NULL));
    /*-----------------------------------------------------------------------*/
    // 初始化WIFI
    init_wifi();
    // 初始化IIS
    init_i2s();
    /*------------------------------------------------------------------------*/
    // 等待事件组设置二进制位
    EventBits_t evbits = xEventGroupWaitBits(
        evt_grp_hd, // 事件组句柄
        // 要等待的二进制位
        EVG_WIFI_CONNECTED_BIT | EVG_NETIF_GOTIP_BIT,
        pdTRUE,       // 自动清除二进制位
        pdTRUE,       // 等待所有位同时有效
        portMAX_DELAY // 一直等待
    );
    if (evbits & EVG_WIFI_CONNECTED_BIT)
    {
        ESP_LOGI("wifi", "wifi已连接");
    }
    if (evbits & EVG_NETIF_GOTIP_BIT)
    {
        ESP_LOGI("wifi", "已获取IP地址");
    }
    // 创建用于发起HTTP请求的任务
    xTaskCreate(
        http_req_task,
        "mytask", // 任务名称
        4096,     // 任务栈大小
        NULL,     // 用户参数,这里无参数
        2,        // 任务优先级
        NULL      // 任务句柄,这里不用存储
    );
    /*
        主任务是允许退出的
    */
}

idf 隐藏了 main 函数,应用程序编写的入口改为 app_main 函数,它实际上是 RTOS 的主任务调用的。可以看看 idf 是如何调用 app_main 的。

static void main_task(void* args)
{
    ESP_LOGI(MAIN_TAG, "Started on CPU%d", (int)xPortGetCoreID());
#if !CONFIG_FREERTOS_UNICORE
    // Wait for FreeRTOS initialization to finish on other core, before replacing its startup stack
    esp_register_freertos_idle_hook_for_cpu(other_cpu_startup_idle_hook_cb, !xPortGetCoreID());
    while (!s_other_cpu_startup_done) {
        ;
    }
    esp_deregister_freertos_idle_hook_for_cpu(other_cpu_startup_idle_hook_cb, !xPortGetCoreID());
#endif

    // [refactor-todo] check if there is a way to move the following block to esp_system startup
    heap_caps_enable_nonos_stack_heaps();

    // Now we have startup stack RAM available for heap, enable any DMA pool memory
#if CONFIG_SPIRAM_MALLOC_RESERVE_INTERNAL
    if (esp_psram_is_initialized()) {
        esp_err_t r = esp_psram_extram_reserve_dma_pool(CONFIG_SPIRAM_MALLOC_RESERVE_INTERNAL);
        if (r != ESP_OK) {
            ESP_LOGE(MAIN_TAG, "Could not reserve internal/DMA pool (error 0x%x)", r);
            abort();
        }
    }
#endif

    // Initialize TWDT if configured to do so
#if CONFIG_ESP_TASK_WDT_INIT
    esp_task_wdt_config_t twdt_config = {
        .timeout_ms = CONFIG_ESP_TASK_WDT_TIMEOUT_S * 1000,
        .idle_core_mask = 0,
#if CONFIG_ESP_TASK_WDT_PANIC
        .trigger_panic = true,
#endif
    };
#if CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0
    twdt_config.idle_core_mask |= (1 << 0);
#endif
#if CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1
    twdt_config.idle_core_mask |= (1 << 1);
#endif
    ESP_ERROR_CHECK(esp_task_wdt_init(&twdt_config));
#endif // CONFIG_ESP_TASK_WDT

    /*
    Note: Be careful when changing the "Calling app_main()" log below as multiple pytest scripts expect this log as a
    start-of-application marker.
    */
    ESP_LOGI(MAIN_TAG, "Calling app_main()");
    extern void app_main(void);
    app_main();
    ESP_LOGI(MAIN_TAG, "Returned from app_main()");
    vTaskDelete(NULL);
}

看到否?app_main 用 extern 修饰,把它声明为由外部其他代码实现的函数,idf 自身不实现,只负责调用。整初始化过程包括 CPU 两个核的初始化,接着是任务看门狗,最后调用 app_main。做完这些后 vTaskDelete(NULL) 表示该任务自杀。从这里也能知道,app_main 函数内是不需要死循环的,当你安排好程序的其他执行任务后,app_main 函数是可以返回的。

看门狗其实是利用定时器,在那里无休止地数咩咩,数着数着它就饿了。你的代码必须在看门狗饿疯之前喂它。看门狗的三观很简单,有得吃就是快乐。如果你的代码不喂狗,看门狗数咩咩数到一定数值(Time out)就会受不了,然后它会强制让开发板重启。看门狗的作用是防止你的程序死机,当开发板过一定时间后没反应,就重启。

任务看门狗就是监听任务队列,所有任务都是抢占 CPU 时间片的(和咱们常说的多线程差不多),当你的任务长时间不让出 CPU 时间片,任务看门狗就认为你这主人可能死机了,这么久不喂狗。由于 idf 默认已配置了一个任务看门狗,所以,你在任务代码是不用刻意去喂狗的,只要你每隔一段时间(没有 Time out 前,这个超时值可以在 SDK 选项中改)让出一下 CPU 时间片,就会自动喂狗了。开发板就不会重启了,最简单的方法就是调用一下 vTaskDelay() 做一下延时,不管延时多长,这个过程都会让出 CPU 时间片。

好,说回 app_main 函数。在这个函数里,咱们做了这几件事:

1、初始化 nvs,前面说了,用来保存配置的。

nvs_flash_init

这里为什么会做两次调用呢,因为这个 nvs 分区一般比较小,有时候存的数据满了(或者是以前的固件存的,现在你的新应用不需要这些垃圾数据),所以,如果初始化不成功,可尝试将 nvs 分区擦除(就像你格式化硬盘分区),这样就有空间来存放新数据了。

2、创建事件队列,前面说了嘛,Wifi 操作使用事件,如果不创建事件队列,那是收不到事件通知的,回调用函数永远无法运行。esp_event_loop_create_default 表示创建默认队列,无需保存变量,因为它由 idf 自动管理。当然,手动创建也可以的,还能选择动态分配或使用静态内存。你看,用 C 语言写就有这好处,灵活,你用 MicroPython、Arduino、.NET Nano 等封装过的框架,是没有这么细节的配置的。

3、xEventGroupCreate 函数创建一个事件分组,这个实际上就是给定一组由二进制位 OR 运算组合的标志。这些标志全是你自己定义,爱怎么定义都行,只要你保证每个标志只占一个二进制位。比如,

【吃饭】 = 0001

那么,接下来定义【啃树皮】就不能用第一位了,只能用2、3、4位任选一。

【啃树皮】 = 0100

如果做 【吃饭】|【啃树皮】运算,那么结果就是 0101,这就能看出,两件事同时发生了。设置二进制位可调用 xEventGroupSetBits 函数(请看前面 Wifi 事件回调函数);而我们的代码可以调用 xEventGroupWaitBits,当你需要的二进制位被设置了,这个函数就会返回。这就类似于线程信号灯,一个点灯,一个等灯。

4、注册事件回调函数。尽管你创建了事件队列,如果不注册回调函数,那么回调函数也不会被触发的。注册回调函数就是告诉事件队列:我对哪些事件感兴趣,并且这些事件发生时你帮我调用 XXX 函数;其他事件我没兴趣,别打扰我

注册事件回调,可以用 esp_event_handler_register 函数,或者 esp_event_handler_instance_register 函数。两者有啥区别?

A、esp_event_handler_register 是旧版函数,但在新版中也兼容的;esp_event_handler_instance_register 是新版本函数,提供给你,但你也可以不用;

B、esp_event_handler_register 函数注册后只告诉你个结果——有没有成功,但不给你任务句柄变量,后面要干吗你无法引用我;而 esp_event_handler_instance_register 函数在注册后会留一个 esp_event_handler_instance_t 类型的变量,后面你想调用其他函数时,可以用这个变量来引用。

这里我用到了两组事件,WIFI_EVENT 是和 wifi 有关的事件,IP_EVENT 是和 IP 地址有关的,因为我要用到 IP_EVENT_STA_GOT_IP 事件。此事件在 ESP 32 连上路由器并获取到 IP 地址后发生。响应此事件可以明确知道:我能上网啦,可以发出 HTTP 请求了。

当所有初始化工作完成后,用 xTaskCreate 创建一个任务,这个任务执行前面写的 http_req_task 函数,不断地接收 PCM 数据,并传给 i2s 接口播放。

    xTaskCreate(
        http_req_task,
        "mytask", // 任务名称
        4096,     // 任务栈大小
        NULL,     // 用户参数,这里无参数
        2,        // 任务优先级
        NULL      // 任务句柄,这里不用存储
    );

 

-------------------------------------------------------------------------------------------------------------------------------------

客户端竣工,现在来搓 HTTP 服务器。服务器直接建一个空白的 ASP.NET Core 项目。

代码很简单,Mini-API 即可胜任。

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.Map("/", () => "洋癫疯音乐服务平台");

app.Map("/song", (IWebHostEnvironment env) =>
{
    // 获取应用程序所在目录
    IFileProvider rootDir = env.ContentRootFileProvider;
    // 从目录下获取PCM音频文件
    var pcmFile = rootDir.GetFileInfo("song.pcm");
    if(pcmFile.Exists)
    {
        // 直接把文件内容以流的形式返回
        return Results.Stream(pcmFile.CreateReadStream(), "application/octet-stream");
    }
    return Results.NotFound();
});

app.Run("http://192.168.1.10:80");

以 IWebHostEnvironment 类型为 API 方法的参数,它会自动注入。然后,用 ContentRootFileProvider 属性就得到了当前 Web 应用程序所在目录,再调用 GetFileInfo 方法就能获取到音频文件了。因为老周把 PCM 文件放在项目目录下。实际使用时,可以在服务器上建一个专用目录,存放文件。

PCM 数据怎么来呢?其实,WAV 文件除去文件头,剩下的就是 PCM 数据了。所以说,WAV 格式的音乐才叫无损。老周找了一首清新女神的歌进行演示,用 FFmpeg 来提取 PCM 数据。

ffmpeg -i "E:\音乐\王韵婵\王韵婵 - 勇敢高飞不寂寞.wav" -f s16le d:\out.pcm

-f 用在 input 之前设置的输入文件的格式,但这里用在输出路径之前,所以设置的是输出文件的格式。s16 表示有符号的 16 整数,le 表示小端。也就是说,咱们提取的 PCM 数据是 Uint16 类型数值,并且低地址存放低字节,高地址存放高字节。如果是大端,就是 s16be。但是,建议使用小端,因为这个比较通用,be 很多时候会出问题。

 

因为在这个例子中,ESP 32 一运行就发出 HTTP 请求的,所以,先运行服务器,然后再给 ESP 上电。老周这里的请求地址是 http://192.168.1.10:80/song,即 http://192.168.1.10/song 就行了。你需要根据实际情况改地址,确保服务器和客户端的地址匹配。

好了,今天就水到这儿了,改天等老周用 .NET Nano framework 做成功了,再写一文来介绍。其实,.NET 封装后的 I2S 调用起来更容易,只是老周自己还没弄成功,所以先不写。老周分享的这些破玩意儿,向来都要亲自验证过才写的。

 

热门相关:新从今天开始做藩王   隔壁的男人王成基   二对一,变态常客   准女婿   怒火狂飙