HAL库STM32F103C8T6通过esp8266发送

下面是一份通过HAL库控制STM32F103C8T6与ESP8266模块通讯的示例代码，可供参考：

#include "stm32f10x.h"
#include "stdio.h"
#include "string.h"
#include "stdlib.h"

/* 定义ESP8266的串口 */
#define ESP_UART USART1

/* 定义ESP8266的AT指令缓冲区大小 */
#define ESP_CMD_BUFFER_SIZE 128

/* 定义ESP8266的WIFI名称和密码 */
#define WIFI_SSID "my_wifi_ssid"
#define WIFI_PASS "my_wifi_password"

/* 定义ESP8266的IP地址和端口 */
#define SERVER_IP "192.168.0.100"
#define SERVER_PORT 8080

/* 定义ESP8266的AT指令响应状态 */
#define ESP_AT_RESPONSE_OK "OK\r\n"
#define ESP_AT_RESPONSE_ERROR "ERROR\r\n"

/* 定义ESP8266的AT指令延迟时间 */
#define ESP_AT_DELAY_MS 100

/* 定义ESP8266的发送和接收缓冲区 */
volatile uint8_t esp_tx_buffer[ESP_CMD_BUFFER_SIZE];
volatile uint8_t esp_rx_buffer[ESP_CMD_BUFFER_SIZE];
volatile uint16_t esp_rx_buffer_index = 0;

/* 定义ESP8266的发送和接收完成标志 */
volatile uint8_t esp_tx_complete = 1;
volatile uint8_t esp_rx_complete = 0;

/* 定义ESP8266的发送和接收回调函数 */
void ESP_UART_TxCpltCallback(void);
void ESP_UART_RxCpltCallback(void);

/* 定义ESP8266的发送和接收函数 */
void ESP_UART_SendData(uint8_t* data, uint16_t size);
void ESP_UART_ReceiveData(uint8_t* data, uint16_t size);

/* 定义ESP8266的AT指令函数 */
uint8_t ESP_AT_Cmd(const char* cmd, const char* expected_response);

/* 定义ESP8266的WIFI连接函数 */
uint8_t ESP_WIFI_Connect(const char* ssid, const char* password);

/* 定义ESP8266的TCP连接函数 */
uint8_t ESP_TCP_Connect(const char* ip, uint16_t port);

/* 定义ESP8266的TCP发送函数 */
uint8_t ESP_TCP_Send(const uint8_t* data, uint16_t size);

int main(void)
{
    /* 初始化ESP8266的GPIO和UART */
    GPIO_InitTypeDef GPIO_InitStruct;
    USART_InitTypeDef USART_InitStruct;
    NVIC_InitTypeDef NVIC_InitStruct;

    /* 打开GPIO和UART的时钟 */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_USART1, ENABLE);

    /* 配置GPIO引脚 */
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_9;
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStruct);

    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_InitStruct.GPIO_Pin = GPIO_Pin_10;
    GPIO_Init(GPIOA, &GPIO_InitStruct);

    /* 配置UART */
    USART_InitStruct.USART_BaudRate = 115200;
    USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStruct.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
    USART_InitStruct.USART_Parity = USART_Parity_No;
    USART_InitStruct.USART_StopBits = USART_StopBits_1;
    USART_InitStruct.USART_WordLength = USART_WordLength_8b;
    USART_Init(ESP_UART, &USART_InitStruct);

    /* 打开UART的中断 */
    USART_ITConfig(ESP_UART, USART_IT_RXNE, ENABLE);
    NVIC_InitStruct.NVIC_IRQChannel = USART1_IRQn;
    NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
    NVIC_Init(&NVIC_InitStruct);

    /* 启动UART */
    USART_Cmd(ESP_UART, ENABLE);

    /* 等待ESP8266启动完成 */
    while (!ESP_AT_Cmd("AT\r\n", ESP_AT_RESPONSE_OK));

    /* 连接WIFI */
    while (!ESP_WIFI_Connect(WIFI_SSID, WIFI_PASS));

    /* 连接TCP服务器 */
    while (!ESP_TCP_Connect(SERVER_IP, SERVER_PORT));

    /* 发送数据 */
    char* data = "Hello, world!";
    ESP_TCP_Send((uint8_t*)data, strlen(data));

    /* 死循环 */
    while (1);
}

void ESP_UART_TxCpltCallback(void)
{
    /* 标记发送完成 */
    esp_tx_complete = 1;
}

void ESP_UART_RxCpltCallback(void)
{
    /* 接收一个字节 */
    uint8_t data = USART_ReceiveData(ESP_UART);

    /* 如果是换行符，则标记接收完成 */
    if (data == '\n') {
        esp_rx_complete = 1;
    }
    /* 否则添加到缓冲区 */
    else {
        esp_rx_buffer[esp_rx_buffer_index++] = data;
    }
}

void ESP_UART_SendData(uint8_t* data, uint16_t size)
{
    /* 等待上一次发送完成 */
    while (!esp_tx_complete);

    /* 复制数据到发送缓冲区 */
    memcpy((void*)esp_tx_buffer, (void*)data, size);

    /* 标记发送未完成 */
    esp_tx_complete = 0;

    /* 发送数据 */
    USART_SendData(ESP_UART, esp_tx_buffer[0]);
    USART_ITConfig(ESP_UART, USART_IT_TXE, ENABLE);
}

void ESP_UART_ReceiveData(uint8_t* data, uint16_t size)
{
    /* 标记接收未完成 */
    esp_rx_buffer_index = 0;
    esp_rx_complete = 0;

    /* 接收数据 */
    USART_ITConfig(ESP_UART, USART_IT_RXNE, ENABLE);
}

uint8_t ESP_AT_Cmd(const char* cmd, const char* expected_response)
{
    /* 发送AT指令 */
    ESP_UART_SendData((uint8_t*)cmd, strlen(cmd));

    /* 等待响应 */
    while (!esp_rx_complete);
    esp_rx_buffer[esp_rx_buffer_index] = '\0';

    /* 检查响应 */
    if (strstr((char*)esp_rx_buffer, expected_response) != NULL) {
        return 1;
    }
    else {
        return 0;
    }
}

uint8_t ESP_WIFI_Connect(const char* ssid, const char* password)
{
    /* 连接WIFI */
    if (!ESP_AT_Cmd("AT+CWJAP=\"", "\"\r\n")) {
        return 0;
    }
    if (!ESP_AT_Cmd(ssid, "\"\r\n")) {
        return 0;
    }
    if (!ESP_AT_Cmd(password, ESP_AT_RESPONSE_OK)) {
        return 0;
    }

    return 1;
}

uint8_t ESP_TCP_Connect(const char* ip, uint16_t port)
{
    /* 设置TCP连接模式 */
    if (!ESP_AT_Cmd("AT+CIPMUX=0\r\n", ESP_AT_RESPONSE_OK)) {
        return 0;
    }

    /* 连接TCP服务器 */
    char cmd[ESP_CMD_BUFFER_SIZE];
    sprintf(cmd, "AT+CIPSTART=\"TCP\",\"%s\",%d\r\n", ip, port);
    if (!ESP_AT_Cmd(cmd, ESP_AT_RESPONSE_OK)) {
        return 0;
    }

    return 1;
}

uint8_t ESP_TCP_Send(const uint8_t* data, uint16_t size)
{
    /* 发送TCP数据 */
    char cmd[ESP_CMD_BUFFER_SIZE];
    sprintf(cmd, "AT+CIPSEND=%d\r\n", size);
    if (!ESP_AT_Cmd(cmd, "> ")) {
        return 0;
    }
    ESP_UART_SendData((uint8_t*)data, size);

    /* 等待发送完成 */
    uint32_t start_time = HAL_GetTick();
    while (!esp_tx_complete && (HAL_GetTick() - start_time < ESP_AT_DELAY_MS));

    /* 检查响应 */
    esp_rx_buffer[esp_rx_buffer_index] = '\0';
    if (strstr((char*)esp_rx_buffer, ESP_AT_RESPONSE_OK) != NULL) {
        return 1;
    }
    else {
        return 0;
    }
}