STM32-LwESP 移植

LwESP 是一个专门解析 Espressif 公司旗下 ESP 系列芯片 AT 指令的开源库，具有以下特性：

支持 Espressif 公司 ESP32, ESP32-C2, ESP32-C3, ESP32-C6 和 ESP8266 芯片。
独立平台，采用 C99 标准编写，易于移植。
允许不同的配置来优化客户的需求。
针对 RTOS 系统进行了优化。
- 有专门的 2 个线程来处理用户的输入和接收的数据
  - Producer 线程：用于从应用程序接收用户命令并执行
  - Process 线程：处理从 ESP 返回的数据
支持在 LwESP 上直接运行以下应用：
- HTTP server
- MQTT client
- Cayenne MQTT server
嵌入其它 AT 指令，如 WPS
用户友好的 MIT License

综上，对于直接运行 AT 固件的 ESP 系列芯片，使用 LwESP 可以直接实现网络功能而无需去研究各种 AT 指令，从而可以让用户专注于应用即可。

这里顺带提一下笔者的开发环境：

MCU：STM32F103RCT6
Library: 标准库 en.stsw-stm32054_v3-6-0 (HAL 库和 LL 库对应参考即可)
RTOS：FreeRTOSv202210.01-LTS

LwESP 移植可以分为以下几步：

下载源码
源码加入工程
接口移植
应用测试

下载源码

LwESP 的源码可以参考 GitHub 上的仓库。一般来说，源码下载只需要下载正式 release 的版本即可，不需要刻意下载 main 和 develop 分支。笔者在写这篇文档时最新的 release 版本为 Release v1.1.2-dev。

Release v1.12 dev

源码加入工程

LwESP 采用 CMake 来构建系统。如果不支持 CMake 的话，LwESP 也支持将源码加入到自己的工程中来编译。笔者使用 KEIL 来编译 STM32，所以需要采用后者的编译方式。

将 LwESP 加入到自己的工程中也很简单，分为几下几步：

将 lwesp 目录拷贝到工程中。lwesp 目录中包含了 LwESP 实现的源码。
在 KEIL 的头文件搜索路径中增加 lwesp/src/include。注意这里头文件的路径只需要 lwesp/src/include 即可，因为在 LwESP 的 C 源文件中包含的头文件类似于 #include "lwesp/lwesp.h，已经以相对路径的方式包含了所需要的头文件，所以这里只包含 lwesp/src/include 这一个头文件路径即可。
将 lwesp 目录下 src 下的所有 C 源文件（除了子目录 system 下的 C 源文件）加入到 KEIL 中。注意 src 目录下又分为了好几个子目录，各个子目录下的 C 源文件都到加入到 KEIL 中。笔者这里就以 src 目录下个各个子目录在 KEIL 中一一进行了逻辑划分。
将 system 下的 C 源文件 lwesp_ll_stm32.c 和 lwesp_sys_freertos.c 加入到 KEIL 中。（为什么单独是这 2 个文件，后面接口移植会说明）
拷贝 lwesp/src/include/lwesp/lwesp_opts_template.h 头文件到工程中并重新命名为 lwesp_opts.h。注意放置头文件 lwesp_opts.h 的所在目录也必须加入到 KEIL 头文件搜索路径中。

注：

system 下的 C 源文件主要分为 3 部分：

示例系统接口，主要针对的是 RTOS
示例芯片驱动，主要针对的是芯片的一些驱动，用于芯片和 ESP 设备之间的物理通信
示例内存管理

System Directory

接口移植

分层结构

在正式移植 LwESP 之前，首先要了解 LwESP 的分层结构。

Architecture

整个 LwESP 可以分为 4 层：

User application
ESP AT Lib middleware
System functions & Low-level functions
ESP8266 or ESP32 physical device

User application:
用户应用层。

ESP AT Lib middleware：
该层不建议用户主动更改。该层是整个 LwESP 的核心层，负责 AT 命令的执行和分析从 ESP 返回的数据。

System functions & Low-level functions：
用户需要完全实现该层的接口。

System functions：该层中的接口是 RTOS 和 ESP AT Lib middleware 层的桥梁。主要分为以下几个接口：
1. 线程管理
2. 二进制信号量管理
3. 递归互斥管理
4. 消息队列管理
5. 当前时间状态信息
Low-level functions：该层中的接口负责 ESP AT Lib middleware 层和 ESP8266 or ESP32 physical device 层之间的通信。

ESP8266 or ESP32 physical device：

移植

了解了 LwESP 的分层结构之后，其实移植工作主要做的工作就是完全实现 System functions & Low-level functions 层。而对于这一层，又可以分为实现 System functions 和 Low-level functions。

System functions 的实现需要根据 MCU 所使用的 RTOS 决定。笔者使用的 RTOS 是 FreeRTOS。对于 FreeRTOS，LwESP 已经提供了现成的示例，路径为 lwesp\src\system\lwesp_sys_freertos.c。只需要将文件拷贝到自己的工程中即可。

Low-level functions 的实现需要根据 MCU 所使用的库来决定。对于 STM32 而言，库可以分为标准库、HAL 库和 LL 库三种。LwESP 提供了基于 LL 库的示例，路径为 lwesp\src\system\lwesp_ll_stm32.c。如果使用的是 LL 库来开发 STM32，则可以直接将其拷贝到自己的工程中。不过 lwesp_ll_stm32.c 中关于 RTOS 的接口是基于 CMSIS-OS，所以如果使用的 RTOS 不是 CMSIS-OS 的话，还需要将 CMSIS-OS 的系统接口替换成自己 RTOS 的系统接口。

笔者的开发环境是 标准库+FreeRTOS 的组合。所以对于 lwesp_ll_stm32.c 文件，移植包括以下几步：

将 LL 开头的 LL 库接口替换成标准库的接口
将 os 开头的 CMSIS-OS 接口替换成 FreeRTOS 接口

通过 lwesp_ll_stm32.c 文件的头部说明可以了解到，LwESP 是使用 UART + DMA 的方式来接收从 ESP 返回的数据。所以这里也需要根据自己使用的 MCU 来确定使用的 UART 和 DMA。笔者这是使用 USART2 和 ESP 通信，根据 STM32F103RCT6 的 Datasheet 可知 USART2 的 DMA 接收通道为 DMA1_Channel6。

DMA

整个 lwesp_ll_stm32.c 修改后如下：

/*** \file            lwesp_ll_stm32.c* \brief           Generic STM32 driver, included in various STM32 driver variants*//** Copyright (c) 2020 Tilen MAJERLE** Permission is hereby granted, free of charge, to any person* obtaining a copy of this software and associated documentation* files (the "Software"), to deal in the Software without restriction,* including without limitation the rights to use, copy, modify, merge,* publish, distribute, sublicense, and/or sell copies of the Software,* and to permit persons to whom the Software is furnished to do so,* subject to the following conditions:** The above copyright notice and this permission notice shall be* included in all copies or substantial portions of the Software.** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE* AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR* OTHER DEALINGS IN THE SOFTWARE.** This file is part of LwESP - Lightweight ESP-AT parser library.** Author:          Tilen MAJERLE <tilen@majerle.eu>* Version:         v1.1.2-dev*//** How it works** On first call to \ref lwesp_ll_init, new thread is created and processed in usart_ll_thread function.* USART is configured in RX DMA mode and any incoming bytes are processed inside thread function.* DMA and USART implement interrupt handlers to notify main thread about new data ready to send to upper layer.** More about UART + RX DMA: https://github.com/MaJerle/stm32-usart-dma-rx-tx** \ref LWESP_CFG_INPUT_USE_PROCESS must be enabled in `lwesp_config.h` to use this driver.*/
#include "stm32f10x.h"#include "lwesp/lwesp.h"
#include "lwesp/lwesp_mem.h"
#include "lwesp/lwesp_input.h"
#include "system/lwesp_ll.h"#if !__DOXYGEN__/* USART */
#define LWESP_USART                           USART2
#define LWESP_USART_CLK                       RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE)
#define LWESP_USART_IRQ                       USART2_IRQn
#define LWESP_USART_IRQHANDLER                USART2_IRQHandler
#define LWESP_USART_RDR_NAME                  DR/* USART TX PIN */
#define LWESP_USART_TX_PORT_CLK               RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE)
#define LWESP_USART_TX_PORT                   GPIOA
#define LWESP_USART_TX_PIN                    GPIO_Pin_2/* USART RX PIN */
#define LWESP_USART_RX_PORT_CLK               RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE)
#define LWESP_USART_RX_PORT                   GPIOA
#define LWESP_USART_RX_PIN                    GPIO_Pin_3/* DMA settings */
#define LWESP_USART_DMA                       DMA1
#define LWESP_USART_DMA_CLK                   RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE)
#define LWESP_USART_DMA_RX_CH                 DMA1_Channel6
#define LWESP_USART_DMA_RX_IRQ                DMA1_Channel6_IRQn
#define LWESP_USART_DMA_RX_IRQHANDLER         DMA1_Channel6_IRQHandler/* RESET PIN */
#define LWESP_RESET_PORT_CLK                  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE)
#define LWESP_RESET_PORT                      GPIOA
#define LWESP_RESET_PIN                       GPIO_Pin_4/* DMA flags management */
#define LWESP_USART_DMA_RX_CLEAR_TC           DMA_ClearFlag(DMA1_IT_TC6)
#define LWESP_USART_DMA_RX_CLEAR_HT           DMA_ClearFlag(DMA1_IT_HT6)#if !LWESP_CFG_INPUT_USE_PROCESS
#error "LWESP_CFG_INPUT_USE_PROCESS must be enabled in `lwesp_config.h` to use this driver."
#endif /* LWESP_CFG_INPUT_USE_PROCESS */#if !defined(LWESP_USART_DMA_RX_BUFF_SIZE)
#define LWESP_USART_DMA_RX_BUFF_SIZE      0x1000
#endif /* !defined(LWESP_USART_DMA_RX_BUFF_SIZE) */#if !defined(LWESP_MEM_SIZE)
#define LWESP_MEM_SIZE                    0x1000
#endif /* !defined(LWESP_MEM_SIZE) */#if !defined(LWESP_USART_RDR_NAME)
#define LWESP_USART_RDR_NAME              RDR
#endif /* !defined(LWESP_USART_RDR_NAME) *//* USART memory */
static uint8_t      usart_mem[LWESP_USART_DMA_RX_BUFF_SIZE];
static uint8_t      is_running, initialized;
static size_t       old_pos;/* USART thread */
static void usart_ll_thread(void* arg);
static TaskHandle_t usart_ll_thread_id;/* Message queue */
static QueueHandle_t usart_ll_mbox_id;/*** \brief           USART data processing*/
static void
usart_ll_thread(void* arg) {size_t pos;LWESP_UNUSED(arg);while (1) {void* d;/* Wait for the event message from DMA or USART */xQueueReceive(usart_ll_mbox_id, &d, portMAX_DELAY);/* Read data */
#if defined(LWESP_USART_DMA_RX_STREAM)pos = sizeof(usart_mem) - LL_DMA_GetDataLength(LWESP_USART_DMA, LWESP_USART_DMA_RX_STREAM);
#elsepos = sizeof(usart_mem) - DMA_GetCurrDataCounter(LWESP_USART_DMA_RX_CH);
#endif /* defined(LWESP_USART_DMA_RX_STREAM) */if (pos != old_pos && is_running) {if (pos > old_pos) {lwesp_input_process(&usart_mem[old_pos], pos - old_pos);} else {lwesp_input_process(&usart_mem[old_pos], sizeof(usart_mem) - old_pos);if (pos > 0) {lwesp_input_process(&usart_mem[0], pos);}}old_pos = pos;if (old_pos == sizeof(usart_mem)) {old_pos = 0;}}}
}/*** \brief           Configure UART using DMA for receive in double buffer mode and IDLE line detection*/
static void
configure_uart(uint32_t baudrate) {static USART_InitTypeDef USART_InitStruct = { 0 };static DMA_InitTypeDef DMA_InitStruct = { 0 };GPIO_InitTypeDef GPIO_InitStructure = { 0 };NVIC_InitTypeDef NVIC_InitStructure = { 0 };if (!initialized) {/* Enable peripheral clocks */LWESP_USART_CLK;LWESP_USART_DMA_CLK;LWESP_USART_TX_PORT_CLK;LWESP_USART_RX_PORT_CLK;#if defined(LWESP_RESET_PIN)LWESP_RESET_PORT_CLK;
#endif /* defined(LWESP_RESET_PIN) */#if defined(LWESP_GPIO0_PIN)LWESP_GPIO0_PORT_CLK;
#endif /* defined(LWESP_GPIO0_PIN) */#if defined(LWESP_GPIO2_PIN)LWESP_GPIO2_PORT_CLK;
#endif /* defined(LWESP_GPIO2_PIN) */#if defined(LWESP_CH_PD_PIN)LWESP_CH_PD_PORT_CLK;
#endif /* defined(LWESP_CH_PD_PIN) */#if defined(LWESP_RESET_PIN)/* Configure RESET pin */memset(&GPIO_InitStructure, 0, sizeof(GPIO_InitTypeDef));GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;GPIO_InitStructure.GPIO_Pin = LWESP_RESET_PIN;GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;GPIO_Init(LWESP_RESET_PORT, &GPIO_InitStructure);
#endif /* defined(LWESP_RESET_PIN) */#if defined(LWESP_GPIO0_PIN)/* Configure GPIO0 pin */gpio_init.Pin = LWESP_GPIO0_PIN;LL_GPIO_Init(LWESP_GPIO0_PORT, &gpio_init);LL_GPIO_SetOutputPin(LWESP_GPIO0_PORT, LWESP_GPIO0_PIN);
#endif /* defined(LWESP_GPIO0_PIN) */#if defined(LWESP_GPIO2_PIN)/* Configure GPIO2 pin */gpio_init.Pin = LWESP_GPIO2_PIN;LL_GPIO_Init(LWESP_GPIO2_PORT, &gpio_init);LL_GPIO_SetOutputPin(LWESP_GPIO2_PORT, LWESP_GPIO2_PIN);
#endif /* defined(LWESP_GPIO2_PIN) */#if defined(LWESP_CH_PD_PIN)/* Configure CH_PD pin */gpio_init.Pin = LWESP_CH_PD_PIN;LL_GPIO_Init(LWESP_CH_PD_PORT, &gpio_init);LL_GPIO_SetOutputPin(LWESP_CH_PD_PORT, LWESP_CH_PD_PIN);
#endif /* defined(LWESP_CH_PD_PIN) *//* Configure USART pins *//* TX PIN */GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;GPIO_InitStructure.GPIO_Pin = LWESP_USART_TX_PIN;GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;GPIO_Init(LWESP_USART_TX_PORT, &GPIO_InitStructure);/* RX PIN */GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;GPIO_InitStructure.GPIO_Pin = LWESP_USART_RX_PIN;GPIO_Init(LWESP_USART_TX_PORT, &GPIO_InitStructure);/* Configure UART */USART_DeInit(LWESP_USART);USART_InitStruct.USART_BaudRate = baudrate;USART_InitStruct.USART_WordLength = USART_WordLength_8b;USART_InitStruct.USART_StopBits = USART_StopBits_1;USART_InitStruct.USART_Parity = USART_Parity_No;USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;USART_InitStruct.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;USART_Init(LWESP_USART, &USART_InitStruct);/* Enable USART interrupts and DMA request */USART_ITConfig(LWESP_USART, USART_IT_IDLE, ENABLE);USART_ITConfig(LWESP_USART, USART_IT_PE, ENABLE);USART_ITConfig(LWESP_USART, USART_IT_ERR, ENABLE);USART_DMACmd(LWESP_USART, USART_DMAReq_Rx, ENABLE);/* Enable USART interrupts */memset(&NVIC_InitStructure, 0, sizeof(NVIC_InitTypeDef));NVIC_InitStructure.NVIC_IRQChannel = LWESP_USART_IRQ;NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 7;NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;NVIC_Init(&NVIC_InitStructure);/* Configure DMA */is_running = 0;
#if defined(LWESP_USART_DMA_RX_STREAM)LL_DMA_DeInit(LWESP_USART_DMA, LWESP_USART_DMA_RX_STREAM);dma_init.Channel = LWESP_USART_DMA_RX_CH;
#else// DMA_DeInit(LWESP_USART_DMA_RX_CH);
#endif /* defined(LWESP_USART_DMA_RX_STREAM) */DMA_InitStruct.DMA_PeripheralBaseAddr = (uint32_t)&(LWESP_USART->LWESP_USART_RDR_NAME);DMA_InitStruct.DMA_MemoryBaseAddr = (uint32_t)usart_mem;DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralSRC;DMA_InitStruct.DMA_BufferSize = sizeof(usart_mem);DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;DMA_InitStruct.DMA_Mode = DMA_Mode_Circular;DMA_InitStruct.DMA_Priority = DMA_Priority_Medium;DMA_InitStruct.DMA_M2M = DMA_M2M_Disable;#if defined(LWESP_USART_DMA_RX_STREAM)LL_DMA_Init(LWESP_USART_DMA, LWESP_USART_DMA_RX_STREAM, &dma_init);
#elseDMA_Init(LWESP_USART_DMA_RX_CH, &DMA_InitStruct);
#endif /* defined(LWESP_USART_DMA_RX_STREAM) *//* Enable DMA interrupts */
#if defined(LWESP_USART_DMA_RX_STREAM)LL_DMA_EnableIT_HT(LWESP_USART_DMA, LWESP_USART_DMA_RX_STREAM);LL_DMA_EnableIT_TC(LWESP_USART_DMA, LWESP_USART_DMA_RX_STREAM);LL_DMA_EnableIT_TE(LWESP_USART_DMA, LWESP_USART_DMA_RX_STREAM);LL_DMA_EnableIT_FE(LWESP_USART_DMA, LWESP_USART_DMA_RX_STREAM);LL_DMA_EnableIT_DME(LWESP_USART_DMA, LWESP_USART_DMA_RX_STREAM);
#elseDMA_ITConfig(LWESP_USART_DMA_RX_CH, DMA_IT_HT, ENABLE);DMA_ITConfig(LWESP_USART_DMA_RX_CH, DMA_IT_TC, ENABLE);DMA_ITConfig(LWESP_USART_DMA_RX_CH, DMA_IT_TE, ENABLE);#endif /* defined(LWESP_USART_DMA_RX_STREAM) *//* Enable DMA interrupts */memset(&NVIC_InitStructure, 0, sizeof(NVIC_InitTypeDef));NVIC_InitStructure.NVIC_IRQChannel = LWESP_USART_DMA_RX_IRQ;NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 6;NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;NVIC_Init(&NVIC_InitStructure);old_pos = 0;is_running = 1;/* Start DMA and USART */
#if defined(LWESP_USART_DMA_RX_STREAM)LL_DMA_EnableStream(LWESP_USART_DMA, LWESP_USART_DMA_RX_STREAM);
#elseDMA_Cmd(LWESP_USART_DMA_RX_CH, ENABLE);
#endif /* defined(LWESP_USART_DMA_RX_STREAM) */USART_Cmd(LWESP_USART, ENABLE);/* Read from the USART_SR register followed by a write to the USART_DR register to clear TC flag */USART_GetFlagStatus(LWESP_USART, USART_FLAG_TC);} else {vTaskDelay(100);USART_Cmd(LWESP_USART, DISABLE);USART_InitStruct.USART_BaudRate = baudrate;USART_Init(LWESP_USART, &USART_InitStruct);USART_Cmd(LWESP_USART, ENABLE);/* Read from the USART_SR register followed by a write to the USART_DR register to clear TC flag */USART_GetFlagStatus(LWESP_USART, USART_FLAG_TC);}/* Create mbox and start thread */if (usart_ll_mbox_id == NULL) {usart_ll_mbox_id = xQueueCreate(10, sizeof(void*));}if (usart_ll_thread_id == NULL) {xTaskCreate(usart_ll_thread, "usart_ll_thread", 1024, NULL, 10, &usart_ll_thread_id);}
}#if defined(LWESP_RESET_PIN)
/*** \brief           Hardware reset callback*/
static uint8_t
reset_device(uint8_t state) {if (state) {/* Activate reset line */GPIO_ResetBits(LWESP_RESET_PORT, LWESP_RESET_PIN);} else {GPIO_SetBits(LWESP_RESET_PORT, LWESP_RESET_PIN);}return 1;
}
#endif /* defined(LWESP_RESET_PIN) *//*** \brief           Send data to ESP device* \param[in]       data: Pointer to data to send* \param[in]       len: Number of bytes to send* \return          Number of bytes sent*/
static size_t
send_data(const void* data, size_t len) {const uint8_t* d = data;for (size_t i = 0; i < len; ++i, ++d) {USART_SendData(LWESP_USART, (uint8_t)(*d));while (USART_GetFlagStatus(LWESP_USART, USART_FLAG_TC) == RESET) {}}return len;
}/*** \brief           Callback function called from initialization process*/
lwespr_t
lwesp_ll_init(lwesp_ll_t* ll) {
#if !LWESP_CFG_MEM_CUSTOMstatic uint8_t memory[LWESP_MEM_SIZE];lwesp_mem_region_t mem_regions[] = {{ memory, sizeof(memory) }};if (!initialized) {lwesp_mem_assignmemory(mem_regions, LWESP_ARRAYSIZE(mem_regions));  /* Assign memory for allocations */}
#endif /* !LWESP_CFG_MEM_CUSTOM */if (!initialized) {ll->send_fn = send_data;                /* Set callback function to send data */
#if defined(LWESP_RESET_PIN)ll->reset_fn = reset_device;            /* Set callback for hardware reset */
#endif /* defined(LWESP_RESET_PIN) */}configure_uart(ll->uart.baudrate);          /* Initialize UART for communication */initialized = 1;return lwespOK;
}/*** \brief           Callback function to de-init low-level communication part*/
lwespr_t
lwesp_ll_deinit(lwesp_ll_t* ll) {if (usart_ll_mbox_id != NULL) {QueueHandle_t tmp = usart_ll_mbox_id;usart_ll_mbox_id = NULL;vQueueDelete(tmp);}if (usart_ll_thread_id != NULL) {TaskHandle_t tmp = usart_ll_thread_id;usart_ll_thread_id = NULL;vTaskDelete(tmp);}initialized = 0;LWESP_UNUSED(ll);return lwespOK;
}/*** \brief           UART global interrupt handler*/
void
LWESP_USART_IRQHANDLER(void) {USART_ClearFlag(LWESP_USART, USART_IT_PE);USART_ClearFlag(LWESP_USART, USART_IT_FE);USART_ClearFlag(LWESP_USART, USART_IT_ORE_ER);USART_ClearFlag(LWESP_USART, USART_IT_NE);if (USART_GetITStatus(LWESP_USART, USART_IT_IDLE) != RESET) {/* Clear IDLE bit */USART_ReceiveData(LWESP_USART);USART_ClearITPendingBit(LWESP_USART, USART_IT_IDLE);}if (usart_ll_mbox_id != NULL) {void* d = (void*)1;xQueueSendToBackFromISR(usart_ll_mbox_id, &d, NULL);}
}/*** \brief           UART DMA stream/channel handler*/
void
LWESP_USART_DMA_RX_IRQHANDLER(void) {LWESP_USART_DMA_RX_CLEAR_TC;LWESP_USART_DMA_RX_CLEAR_HT;if (usart_ll_mbox_id != NULL) {void* d = (void*)1;xQueueSendToBackFromISR(usart_ll_mbox_id, &d, NULL);}
}#endif /* !__DOXYGEN__ */

这里在补充一下，除了 USART2 所使用的 TX 和 RX 引脚外，LwESP 还约定了其它的一些引脚，对于 ESP32 系列，LwESP 还添加了宏定义 LWESP_RESET_PIN 用来控制 ESP32 RST 引脚。而对于 ESP8266 系列，LwESP 定义了 LWESP_GPIO0_PIN,LWESP_GPIO2_PIN 和 LWESP_CH_PD_PIN。对于感兴趣的读者，可以参考 LwESP 的官方文档中的 Examples and demos。

到这里，整个移植工作就全部完成了，剩下的工作就是写个应用 Demo 来测试下。

应用测试

LwESP 已经帮我们实现了大部分的应用接口。对于经常使用的一些 TCP, UDP, MQTT 和 HTTP 的功能，LwESP 在目录 snippets 下提供了现成的源文件。LwESP 也针对 STM32 提供了现成的应用示例，只需要参考下即可，路径为 examples\stm32。

Examples

笔者这里参考 Demo netconn_client_rtos_stm32l496g_discovery，简单的写了个应用。就简简单单的在加入 AP 后与指定的 TCP Server 建立连接，之后发送一个 GET 请求。main.c 如下：

/********************************************************************************* @file    Project/STM32F10x_StdPeriph_Template/main.c * @author  MCD Application Team* @version V3.6.0* @date    20-September-2021* @brief   Main program body******************************************************************************* @attention** Copyright (c) 2011 STMicroelectronics.* All rights reserved.** This software is licensed under terms that can be found in the LICENSE file* in the root directory of this software component.* If no LICENSE file comes with this software, it is provided AS-IS.********************************************************************************//* Includes ------------------------------------------------------------------*/
#include <stdio.h>
#include "stm32f10x.h"
#include "lwesp_opts.h"#include "FreeRTOS.h"
#include "task.h"#include "printf.h"
#include "delay.h"#include "lwesp/lwesp.h"
#include "station_manager.h"
#include "netconn_client.h"/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
lwespr_t lwesp_callback_func(lwesp_evt_t* evt) {switch (lwesp_evt_get_type(evt)) {case LWESP_EVT_AT_VERSION_NOT_SUPPORTED: {lwesp_sw_version_t v_min, v_curr;lwesp_get_min_at_fw_version(&v_min);lwesp_get_current_at_fw_version(&v_curr);printf("Current ESP8266 AT version is not supported by library!\r\n");printf("Minimum required AT version is: %d.%d.%d\r\n", (int)v_min.major, (int)v_min.minor, (int)v_min.patch);printf("Current AT version is: %d.%d.%d\r\n", (int)v_curr.major, (int)v_curr.minor, (int)v_curr.patch);break;}case LWESP_EVT_INIT_FINISH: {printf("Library initialized!\r\n");break;}case LWESP_EVT_RESET_DETECTED: {printf("Device reset detected!\r\n");break;}case LWESP_EVT_WIFI_IP_ACQUIRED: {        /* We have IP address and we are fully ready to work */if (lwesp_sta_is_joined()) {          /* Check if joined on any network */lwesp_sys_thread_create(NULL, "netconn_client", (lwesp_sys_thread_fn)netconn_client_thread, NULL, 512, LWESP_SYS_THREAD_PRIO);}break;}case LWESP_EVT_WIFI_CONNECTED: {printf("Successfully joined AP\r\n");break;}default:break;}return lwespOK;
}void join_ap_test(void *pvParameters)
{/* Initialize ESP with default callback function */printf("Initializing LwESP\r\n");if (lwesp_init(lwesp_callback_func, 1) != lwespOK) {printf("Cannot initialize LwESP!\r\n");} else {printf("LwESP initialized!\r\n");}/** Continuously try to connect to WIFI network* but only in case device is not already connected*/while (1) {if (!lwesp_sta_is_joined()) {/** Connect to access point.** Try unlimited time until access point accepts up.* Check for station_manager.c to define preferred access points ESP should connect to*/connect_to_preferred_access_point(1);}vTaskDelay(1000);}vTaskDelete(NULL);
}/*** @brief  Configures the nested vectored interrupt controller.* @param  None* @retval None*/
void NVIC_Configuration(void)
{/* Configure the NVIC Preemption Priority Bits */  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
}/*** @brief  Main program.* @param  None* @retval None*/
int main(void)
{/*!< At this stage the microcontroller clock setting is already configured, this is done through SystemInit() function which is called from startupfile (startup_stm32f10x_xx.s) before to branch to application main.To reconfigure the default setting of SystemInit() function, refer tosystem_stm32f10x.c file*//* Add your application code here*/BaseType_t xReturn = pdPASS;NVIC_Configuration();debug_uart_init();printf("Debug UART output success\r\n");xReturn = xTaskCreate(join_ap_test, "join_ap_test", 1024 * 2, NULL, 1, NULL);if(pdPASS == xReturn)vTaskStartScheduler();elsereturn -1;/* Infinite loop */while (1);
}#ifdef  USE_FULL_ASSERT/*** @brief  Reports the name of the source file and the source line number*         where the assert_param error has occurred.* @param  file: pointer to the source file name* @param  line: assert_param error line source number* @retval None*/
void assert_failed(uint8_t* file, uint32_t line)
{ /* User can add his own implementation to report the file name and line number,ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) *//* Infinite loop */while (1){}
}
#endif

要运行这个 Demo，还需要 snippets 目录下的几个源文件 station_manager.c, utils.c 和 netconn_client.c。因为 main.c 中调用了这几个源文件中的接口，需要将它们也拷贝到自己的工程中。同时也需要将 snippets/include 中包含到的头文件也添加到自己的工程中，同时不要忘记头文件放置目录也需要添加到 KEIL 的头文件搜索路径中。

Snippets

Demo 跑起来还需要配置以下参数：

AP 的 SSID 和 PASSWORD
TCP Server 的 IP 地址和连接端口
发送给 TCP Server 的数据

AP 的 SSID 和 PASSWORD 可以在 station_manager.c 中的 ap_list_preferred 中定义：

/** List of preferred access points for ESP device* SSID and password** ESP will try to scan for access points* and then compare them with the one on the list below*/
static const ap_entry_t ap_list_preferred[] = {//{ .ssid = "SSID name", .pass = "SSID password" },{ .ssid = "HUAWEI-tangxiang", .pass = "xxxxxxxx" },
};

TCP Server 的 IP 地址和连接端口 可以在 netconn_client.c 中定义：

/*** \brief           Host and port settings*/
#define NETCONN_HOST        "106.14.142.xxx"
#define NETCONN_PORT        8001

发送给 TCP Server 的数据 可以在 netconn_client.c 中定义，LwESP 默认在 TCP 连接建立后发送一个 GET 请求。

/*** \brief           Request header to send on successful connection*/
static const char
request_header[] = """GET / HTTP/1.1\r\n""Host: " NETCONN_HOST "\r\n""Connection: close\r\n""\r\n";

配置完成后，就可以将 STM32 的 USART2 的 TX 和 RX 引脚与 ESP32 相连，同时可以将 STM32 上定义的 RESET 引脚连接到 ESP32 上的 RST 引脚上。等待 STM32 连接上指定的 AP 后就会自动和指定的 TCP Server 建立 TCP 连接，连接成功后就会自动发送一个 GET 请求。

Connect