STM32与ESP8266的使用

已于 2024-09-27 00:21:03 修改
阅读量2.1k 收藏 26
点赞数 5
分类专栏： 嵌入式学习日记 stm32 文章标签： stm32 单片机 嵌入式硬件
于 2024-09-12 16:40:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51830537/article/details/142152090
版权

串口透传

  • “透传”通常指的是数据的透明传输，意思是在不对数据进行任何处理或修改的情况下，将数据从一个接口转发到另一个接口。
  • 值得注意的是要避免串口之间无限制的透明，可以采用互斥锁的方式进行限制
  • 使用方法
  1. 对USART1和USART3(用他俩举例)的模式都是设置为Asynchronous，并开启对应的中断。
  2. RCC的High SPeed CLock模式设置为Crystal/Ceramic
  3. 配置对应的时钟为64Mhz
  4. 在main函数中启动串口1和串口3的空闲中断模式，接收数据 HAL_UARTEx_ReceiveToIdle_IT(&huart1, rxbuf1, sizeof(rxbuf1));
    HAL_UARTEx_ReceiveToIdle_IT(&huart3, rxbuf3, sizeof(rxbuf3));
  5. 在void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef* huart, uint16_t Size)写对应的透传即可
  • 代码示例
#include "main.h"
#include <string.h>

UART_HandleTypeDef huart1; // 定义串口1的句柄
UART_HandleTypeDef huart3; // 定义串口3的句柄

char rxbuf1[128] = {0}; // 用于接收串口1数据的缓冲区
char rxbuf3[128] = {0}; // 用于接收串口3数据的缓冲区
uint8_t uart1_to_uart3_enable = 1;  // 控制串口1是否允许发送数据到串口3的标志位
uint8_t uart3_to_uart1_enable = 1;  // 控制串口3是否允许发送数据到串口1的标志位

/**
 * @brief 串口接收中断回调函数
 * 该函数在接收到数据后触发，并根据当前接收的是串口1还是串口3的数据，进行对应的处理。
 * @param huart 串口句柄
 * @param Size 接收到的数据大小
 */
void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef* huart, uint16_t Size)
{
    printf("HAL_UARTEx_RxEventCallback triggered\n");
    
    // 判断当前接收的数据是否来自串口1，并且标志位允许发送给串口3
    if (huart == &huart1 && uart1_to_uart3_enable)
    {
        uart3_to_uart1_enable = 0; // 禁止串口3将数据回传给串口1，防止死循环
        HAL_UART_Transmit(&huart3, (uint8_t*)rxbuf1, Size, HAL_MAX_DELAY); // 将串口1接收的数据发送给串口3
        memset(rxbuf1, 0, sizeof(rxbuf1)); // 清空串口1接收缓冲区
        HAL_UARTEx_ReceiveToIdle_IT(&huart1, rxbuf1, sizeof(rxbuf1)); // 重新启动串口1接收中断
        uart3_to_uart1_enable = 1; // 允许串口3传输数据到串口1
        printf("port1 sent to port 3\n");
    }
    // 判断当前接收的数据是否来自串口3，并且标志位允许发送给串口1
    else if (huart == &huart3 && uart3_to_uart1_enable)
    {
        uart1_to_uart3_enable = 0; // 禁止串口1将数据回传给串口3，防止死循环
        HAL_UART_Transmit(&huart1, (uint8_t*)rxbuf3, Size, HAL_MAX_DELAY); // 将串口3接收的数据发送给串口1
        memset(rxbuf3, 0, sizeof(rxbuf3)); // 清空串口3接收缓冲区
        HAL_UARTEx_ReceiveToIdle_IT(&huart3, rxbuf3, sizeof(rxbuf3)); // 重新启动串口3接收中断
        uart1_to_uart3_enable = 1; // 允许串口1传输数据到串口3
        printf("port3 sent to port 1\n");
    }
    return;
}

/**
 * @brief 重定向printf函数，将其输出重定向到串口1
 * @param ch 需要输出的字符
 * @return 返回输出的字符
 */
int __io_putchar(int ch)
{
    HAL_UART_Transmit(&huart1, (unsigned char*)&ch, 1, HAL_MAX_DELAY); // 将字符通过串口1发送
    return ch; // 返回字符
}

/**
 * @brief 主函数
 */
int main(void)
{
    HAL_Init(); // 初始化HAL库
    SystemClock_Config(); // 配置系统时钟
    MX_GPIO_Init(); // 初始化GPIO
    MX_USART1_UART_Init(); // 初始化串口1
    MX_USART3_UART_Init(); // 初始化串口3

    // 启动串口1和串口3的空闲中断模式，接收数据
    HAL_UARTEx_ReceiveToIdle_IT(&huart1, rxbuf1, sizeof(rxbuf1));
    HAL_UARTEx_ReceiveToIdle_IT(&huart3, rxbuf3, sizeof(rxbuf3));

    while (1)
    {
        // 主循环中可以进行其他任务处理
    }
}

/**
 * @brief 配置系统时钟
 * 设置MCU的时钟源、倍频系数等，保证系统运行在正确的时钟频率
 */
void SystemClock_Config(void)
{
    RCC_OscInitTypeDef RCC_OscInitStruct = {0}; // 配置RCC振荡器参数
    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0}; // 配置RCC时钟源及分频系数

    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE; // 使用外部高速振荡器（HSE）
    RCC_OscInitStruct.HSEState = RCC_HSE_ON; // 开启HSE
    RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1; // HSE预分频值为1
    RCC_OscInitStruct.HSIState = RCC_HSI_ON; // 开启内部高速振荡器（HSI）
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON; // 开启PLL
    RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE; // PLL时钟源为HSE
    RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL8; // PLL倍频系数为8
    if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
    {
        Error_Handler(); // 时钟配置失败，进入错误处理函数
    }

    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2; // 配置不同的时钟类型
    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK; // 系统时钟源设置为PLL
    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1; // AHB时钟不分频
    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2; // APB1时钟分频系数为2
    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1; // APB2时钟不分频

    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
    {
        Error_Handler(); // 时钟配置失败，进入错误处理函数
    }
}

/**
 * @brief 初始化串口1
 * 配置波特率、数据位、停止位等串口参数
 */
static void MX_USART1_UART_Init(void)
{
    huart1.Instance = USART1; // 设置串口1的实例
    huart1.Init.BaudRate = 115200; // 波特率设置为115200
    huart1.Init.WordLength = UART_WORDLENGTH_8B; // 数据位长度为8位
    huart1.Init.StopBits = UART_STOPBITS_1; // 停止位为1位
    huart1.Init.Parity = UART_PARITY_NONE; // 无校验位
    huart1.Init.Mode = UART_MODE_TX_RX; // 使能接收和发送模式
    huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE; // 不使用硬件流控
    huart1.Init.OverSampling = UART_OVERSAMPLING_16; // 过采样设置为16倍
    if (HAL_UART_Init(&huart1) != HAL_OK)
    {
        Error_Handler(); // 初始化失败，进入错误处理函数
    }
}

/**
 * @brief 初始化串口3
 * 配置波特率、数据位、停止位等串口参数
 */
static void MX_USART3_UART_Init(void)
{
    huart3.Instance = USART3; // 设置串口3的实例
    huart3.Init.BaudRate = 115200; // 波特率设置为115200
    huart3.Init.WordLength = UART_WORDLENGTH_8B; // 数据位长度为8位
    huart3.Init.StopBits = UART_STOPBITS_1; // 停止位为1位
    huart3.Init.Parity = UART_PARITY_NONE; // 无校验位
    huart3.Init.Mode = UART_MODE_TX_RX; // 使能接收和发送模式
    huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE; // 不使用硬件流控
    huart3.Init.OverSampling = UART_OVERSAMPLING_16; // 过采样设置为16倍
    if (HAL_UART_Init(&huart3) != HAL_OK)
    {
        Error_Handler(); // 初始化失败，进入错误处理函数
    }
}

/**
 * @brief GPIO初始化
 * 配置GPIO端口，用于其他硬件外设，如LED、按键等
 */
static void MX_GPIO_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    // 启用GPIO时钟
    __HAL_RCC_GPIOD_CLK_ENABLE();
    __HAL_RCC_GPIOB_CLK_ENABLE();
    __HAL_RCC_GPIOC_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();

    // 配置PC6、PC7、PC8引脚为推挽输出模式，初始化为低电平，用于驱动LED或其他外设
    HAL_GPIO_WritePin(GPIOC, GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_8, GPIO_PIN_RESET);

    GPIO_InitStruct.Pin = GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_8; // 设置要配置的引脚
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; // 配置为推挽输出模式
    GPIO_InitStruct.Pull = GPIO_NOPULL; // 不使用上拉或下拉电阻
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; // 设置为低速
    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); // 初始化GPIO端口PC6、PC7、PC8
}

/**
 * @brief 错误处理函数
 * 当系统发生错误时调用该函数。可以在此函数中添加错误处理逻辑，如重启系统或记录日志。
 */
void Error_Handler(void)
{
    __disable_irq(); // 禁用全局中断，防止进一步的干扰
    while (1) 
    {
        // 无限循环，防止系统继续运行。可以在此添加LED闪烁等故障指示
    }
}

#ifdef USE_FULL_ASSERT
/**
 * @brief 断言失败时调用此函数
 * 当遇到断言参数错误时，报告源文件和行号，帮助调试
 * @param file 指向发生错误的源文件名的指针
 * @param line 发生错误的代码行号
 */
void assert_failed(uint8_t *file, uint32_t line)
{
    // 可以在此添加打印或记录错误的实现，例如：
    // printf("Wrong parameters value: file %s on line %d\r\n", file, line);
}
#endif /* USE_FULL_ASSERT */

ESP8266与STM32

  • ESP8266 是一款集成了Wi-Fi通信功能的低功耗微控制器，广泛应用于物联网（IoT）设备中。
  • 使用AT指令进行通信
    • STM32与ESP8266通常通过UART（串行通信接口）进行通信。STM32发送AT指令到ESP8266模块，模块根据指令进行网络连接、数据传输等操作，并通过串口返回执行结果。
    • 常见的AT指令
AT 指令说明
AT测试连接，返回“OK”表示模块工作正常。
AT+RST重启ESP8266。
AT+CWMODE设置ESP8266的工作模式（STA、AP或STA+AP）。
AT+CWJAP连接Wi-Fi网络，提供SSID和密码。
AT+CIPSTART启动TCP/UDP连接，常用于连接服务器。
AT+CIPSEND发送数据到服务器。
AT+CIPCLOSE关闭网络连接。
- ESP8266执行命令后，会返回执行结果，通常为“OK”或“ERROR”，我们需要通过UART接收这些数据

// 连接到服务器
void Connect_To_Server(char *ip, uint16_t port) {
    char cmd[100];
    sprintf(cmd, "AT+CIPSTART=\"TCP\",\"%s\",%d\r\n", ip, port);
    UART_Send_AT_Command(cmd);
}
  • 有三种模式
    • Station 模式：可以像普通的 Wi-Fi 设备一样连接到现有的无线网络。
    • AP 模式：可以创建自己的 Wi-Fi 热点，让其他设备连接到 ESP8266。
    • Station + Access Point 混合模式（STA + AP 模式）:ESP8266 同时充当客户端和热点，既可以连接到现有的 Wi-Fi 网络（作为 STA），又可以作为热点允许其他设备连接到它（作为 AP）。
AT+CWMODE=1：设置为 Station 模式。
AT+CWMODE=2：设置为 AP 模式。
AT+CWMODE=3：设置为 STA + AP 混合模式。
  • 服务器
www.daxia.com//下载SSCOM即可
STATION模式
  • 配置uart1- printf，uart3-esp上网（因为WiFi芯片在串口3）
    在这里插入图片描述
使用方法
  • 新建stm32工程中添加WiFi-ops.c和WiFi-ops.h
  • 开启时钟频率为64Mhz和RCC的Crystal
  • 开启UART1和UART3串口为异步通信，且开启中断。
  • 并配置LED灯管脚留作测试
  • 代码示例
#include "main.h"
#include "stdio.h"
#include "string.h"
#include "wifi-ops.h"

// UART句柄
UART_HandleTypeDef huart1;
UART_HandleTypeDef huart3;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_USART3_UART_Init(void);
// 日志状态标志
int log_success_flags = 0;  // 0 - 未初始化，1 - 日志成功，2 - 日志失败

/**
 * @brief  ESP8266 Station模式回调函数
 * @param  data: 接收到的数据
 * @param  len: 数据长度
 * @retval 返回值说明
 */
int esp_station_callback(char *data, int len)
{
    printf("recv from serv: %s\r\n", data);

    // 更新日志状态标志
    if (strstr(data, "log success")) {
        log_success_flags = 1;
    } else if (strstr(data, "log failed")) {
        log_success_flags = 2;
    }

    return 0;
}

/**
 * @brief  UART接收事件回调函数
 * @param  huart: UART句柄
 * @param  Size: 接收的数据大小
 * @retval None
 */
void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
{
    // 处理接收事件，没有传给另一个串口
    wifi_uart_prepare_idle(huart);  // 接收完成后，准备UART进行下一次接收
}

/**
 * @brief  重定向putchar到UART1
 * @param  ch: 要发送的字符
 * @retval 返回发送的字符
 */
int __io_putchar(int ch)
{
    HAL_UART_Transmit(&huart1, (unsigned char *)&ch, 1, 1);
    return ch;
}

/**
 * @brief  主函数入口
 * @retval 程序返回值
 */
int main(void)
{
    HAL_Init(); // 初始化HAL库
    SystemClock_Config(); // 配置系统时钟

    // 初始化所有配置的外设
    MX_GPIO_Init();
    MX_USART1_UART_Init();
    MX_USART3_UART_Init();

    int ret;
    char sendbuf[128] = {0}; // 用于发送数据的缓冲区

    // 准备UART3进行ESP8266通信，使用串口3
    wifi_uart_prepare_idle(&huart3);

    // 初始化ESP8266 Station模式，使用串口3
    ret = wifi_station_init(&huart3, esp_station_callback);
    if (ret < 0) {
        printf("%s-%d wifi_station_init err\r\n", __func__, __LINE__);
        return -35;
    }

    // 连接到指定的AP
    ret = wifi_station_join_ap(&huart3, "xiaomimobile", "12345600");
    if (ret < 0) {
        printf("%s-%d wifi_station_join_ap err\r\n", __func__, __LINE__);
        return -35;
    }

    // 连接到指定的TCP服务器
    ret = wifi_station_tcp_connect(&huart3, "107.148.201.156", 10005);
    if (ret < 0) {
        printf("%s-%d wifi_station_tcp_connect err\r\n", __func__, __LINE__);
        return -35;
    }

    // 发送日志请求数据。特定格式
    snprintf(sendbuf, sizeof(sendbuf), "toServ:action=log,usrname=%s,passwd=%s,devname=sml001;", "xiaowang", "123456");
    ret = wifi_station_tcp_send_data(&huart3, sendbuf, strlen(sendbuf));
    if (ret < 0) {
        printf("%s-%d wifi_station_tcp_send_data err\r\n", __func__, __LINE__);
    }

    // 等待日志发送结果
    for (int i = 0; i < 50; i++) {
        if (log_success_flags == 2) {
            printf("%s-%d log failed \r\n", __func__, __LINE__);
            return -23;
        } else if (log_success_flags == 1) {
            printf("%s-%d log success \r\n", __func__, __LINE__);
            break;
        }
        HAL_Delay(10);
    }

    // 循环发送获取时间请求，这个是该服务器的特定格式
    strcpy(sendbuf, "toServ:action=gettime;");
    while (1)
    {
        ret = wifi_station_tcp_send_data(&huart3, sendbuf, strlen(sendbuf));
        if (ret < 0) {
            printf("%s-%d wifi_station_tcp_send_data err\r\n", __func__, __LINE__);
        }

        HAL_Delay(500); // 等待500毫秒
    }
}

/**
 * @brief  配置系统时钟
 * @retval None
 */
void SystemClock_Config(void)
{
    RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

    // 初始化RCC振荡器
    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
    RCC_OscInitStruct.HSEState = RCC_HSE_ON;
    RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
    RCC_OscInitStruct.HSIState = RCC_HSI_ON;
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
    RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL8;
    if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {
        Error_Handler();
    }

    // 初始化CPU、AHB和APB总线时钟
    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK) {
        Error_Handler();
    }
}

/**
 * @brief  初始化USART1
 * @retval None
 */
static void MX_USART1_UART_Init(void)
{
    huart1.Instance = USART1;
    huart1.Init.BaudRate = 115200;
    huart1.Init.WordLength = UART_WORDLENGTH_8B;
    huart1.Init.StopBits = UART_STOPBITS_1;
    huart1.Init.Parity = UART_PARITY_NONE;
    huart1.Init.Mode = UART_MODE_TX_RX;
    huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    if (HAL_UART_Init(&huart1) != HAL_OK) {
        Error_Handler();
    }
}

/**
 * @brief  初始化USART3
 * @retval None
 */
static void MX_USART3_UART_Init(void)
{
    huart3.Instance = USART3;
    huart3.Init.BaudRate = 115200;
    huart3.Init.WordLength = UART_WORDLENGTH_8B;
    huart3.Init.StopBits = UART_STOPBITS_1;
    huart3.Init.Parity = UART_PARITY_NONE;
    huart3.Init.Mode = UART_MODE_TX_RX;
    huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart3.Init.OverSampling = UART_OVERSAMPLING_16;
    if (HAL_UART_Init(&huart3) != HAL_OK) {
        Error_Handler();
    }
}

/**
 * @brief  初始化GPIO
 * @retval None
 */
static void MX_GPIO_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    // 启用GPIO端口时钟
    __HAL_RCC_GPIOD_CLK_ENABLE();
    __HAL_RCC_GPIOB_CLK_ENABLE();
    __HAL_RCC_GPIOC_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();

    // 配置GPIO输出级别
    HAL_GPIO_WritePin(GPIOC, GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_8, GPIO_PIN_RESET);

    // 配置GPIO引脚
    GPIO_InitStruct.Pin = GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_8;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
}

/**
 * @brief  错误处理函数
 * @retval None
 */
void Error_Handler(void)
{
    __disable_irq();
    while (1) {
    }
}

/**
 * @brief  报告断言失败的文件名和行号
 * @param  file: 源文件名
 * @param  line: 错误行号
 * @retval None
 */
void assert_failed(uint8_t *file, uint32_t line)
{
    // 用户可以添加自己的实现来报告文件名和行号
}
混合模式
  • 默认情况下，ESP8266 的 IP 地址在 AP 模式下是 192.168.4.1，以便其他设备连接到该 AP 时可以进行通信。
  • 代码

#include "main.h"


#include "stdio.h"
#include "string.h"
#include "wifi-ops.h"


UART_HandleTypeDef huart1;
UART_HandleTypeDef huart3;


void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_USART3_UART_Init(void);



#ifdef ESP_STATION

/*当stm32收到 esp/服务器发来消息, 会自动执行该函数
 * 	data,len 表示收到的具体数据和长度
 *
 *
 * 该函数是在 中断执行,不好执行耗时/睡眠工作
 * */

int log_success_flags = 0;		//0-uninit  1-log  2-failed

int esp_station_callback (char *data,int len)
{
	printf("recv from serv: %s\r\n",data);

	//登陆成功失败标志位
	if( strstr(data,"log success") ){
		log_success_flags = 1;
	}else if(strstr(  data, "log failed")){
		log_success_flags = 2;
	}

}
#endif


/* 希望手机发来消息,该函数 被调用,  data len分别是对方发来的消息和长度*/
int esp_ap_callback(char *data,int len)
{
	printf("recv from phone: %s\r\n",data);		//cmd:wifiname=hyx,wifipasswd=8888888,usrname=xiaowang,passwd=123456;
}


void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
{
	//other thing to do
	wifi_uart_prepare_idle(huart);	//after recv success, wo must prepare uart for next time
}




int __io_putchar(int ch)
{
	HAL_UART_Transmit(&huart1, (unsigned char *)&ch,  1,     1);
	return ch;
}


int main(void)
{
  
  HAL_Init();

 
  SystemClock_Config();

  MX_GPIO_Init();
  MX_USART1_UART_Init();
  MX_USART3_UART_Init();
  /* USER CODE BEGIN 2 */

  int ret;
  int linkid;	//每个手机都可以连接ap,都会安排一个id
  char sendbuf[128]={0};

#ifdef ESP_STATION
  //预处理uart3 for esp ...

  wifi_uart_prepare_idle(&huart3);
  ret = wifi_station_init(&huart3,  esp_station_callback );
  if(ret < 0 ){	printf("%s-%d wifi_station_init err\r\n",__func__,__LINE__);		return -35;}
  ret = wifi_station_join_ap(&huart3,"WANGQINGFA","1234567890");
  if(ret < 0 ){	printf("%s-%d wifi_station_join_ap err\r\n",__func__,__LINE__);		return -35;}
  ret = wifi_station_tcp_connect(&huart3,"107.148.201.156",10001);
  if(ret < 0 ){	printf("%s-%d wifi_station_tcp_connect err\r\n",__func__,__LINE__);	return -35;}

  /*登陆服务器		toServ:action=log,usrname=xiaowang,passwd=123456,devname=sml001;		*/
  snprintf(sendbuf,sizeof(sendbuf), "toServ:action=log,usrname=%s,passwd=%s,devname=sml001;","xiaowang","123456" );
  ret = wifi_station_tcp_send_data(&huart3,sendbuf,strlen(sendbuf));
  if(ret < 0 ){	printf("%s-%d wifi_station_tcp_connect err\r\n",__func__,__LINE__);	   }

  for(int i=0;i<50;i++){
	  if(log_success_flags == 2){
		  printf("%s-%d log failed \r\n",__func__,__LINE__);
		  return -23;
	  }else if(log_success_flags == 1){
		  printf("%s-%d log success \r\n",__func__,__LINE__);
		  break;
	  }
	  HAL_Delay(10);
  }
#endif

  wifi_uart_prepare_idle(&huart3);
  ret = wifi_ap_init(&huart3,  esp_ap_callback);
  if(ret < 0 ){	printf("%s-%d wifi_ap_init err\r\n",__func__,__LINE__);		return -35;}
  ret = wifi_ap_set_args(&huart3, "zhangsan","12345678");
  if(ret < 0 ){	printf("%s-%d wifi_ap_set_args err\r\n",__func__,__LINE__);		return -35;}
  linkid = wifi_ap_tcp_listen_and_wait_connect_timeout(&huart3,10001,     5*60*1000);
  if(linkid < 0 ){	printf("%s-%d wifi_ap_tcp_listen_and_wait_connect_timeout err\r\n",__func__,__LINE__);		return -35;}
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  strcpy(sendbuf,"cmd:hello phone,I have got you messgae,please reset it;");
  while (1)
  {

	  wifi_ap_tcp_send_data(&huart3, linkid , sendbuf,strlen(sendbuf)    );


#ifdef ESP_STATION
	  ret = wifi_station_tcp_send_data(&huart3,sendbuf,strlen(sendbuf));
	  if(ret < 0 ){	printf("%s-%d wifi_station_tcp_connect err\r\n",__func__,__LINE__);	   }
#endif
	  HAL_Delay(500);
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL8;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief USART1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART1_UART_Init(void)
{

  /* USER CODE BEGIN USART1_Init 0 */

  /* USER CODE END USART1_Init 0 */

  /* USER CODE BEGIN USART1_Init 1 */

  /* USER CODE END USART1_Init 1 */
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 115200;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }


}


static void MX_USART3_UART_Init(void)
{

  huart3.Instance = USART3;
  huart3.Init.BaudRate = 115200;
  huart3.Init.WordLength = UART_WORDLENGTH_8B;
  huart3.Init.StopBits = UART_STOPBITS_1;
  huart3.Init.Parity = UART_PARITY_NONE;
  huart3.Init.Mode = UART_MODE_TX_RX;
  huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart3.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart3) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART3_Init 2 */

  /* USER CODE END USART3_Init 2 */

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOD_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_6|GPIO_PIN_7|GPIO_PIN_8, GPIO_PIN_RESET);

  /*Configure GPIO pins : PC6 PC7 PC8 */
  GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7|GPIO_PIN_8;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#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 CODE BEGIN 6 */
  /* 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) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */
  • 如图所示，用的TCP/IP调试软件
    在这里插入图片描述
每天的积累
关注
专栏目录
【开源项目自学笔记】STM32与ESP8266通讯
weixin_42780518的博客
06-08 4773
这个项目学习了这几块内容：stm32的串口中断，定时器中断，时间片轮询机制，esp8266，DTH11温湿度传感器的使用。对串口通信收发数据的处理。设计知识点：串口的格式化打印。DWT内核精确延时。sysTick延时。一、DTH11介绍DTH11是串行接口，单线双向。一次一次完整的数据传输为40bit,高位先出。数据格式:8bit湿度整数数据+8bit湿度小数数据 +8bi温度整数数据+8bit温度小数数据 +8bit校验。
STM32通过esp8266连接WiFi接入MQTT服务器
嵌入式
06-03 1万+
STM32通过esp8266连接WiFi接入MQTT服务器
esp8266和stm32驱动之二实现无线通信
10-16
esp8266 和 stm32 实现交互， 可以使得esp8266连接路由器，实现网络下和 电脑 等无线设备的 tcp/ip通信， esp8266 和 stm32的案例，无线通信，如果没有电脑端的tcp/ip软件，可以下载我的另外一个java写的tcp/ip通信小案例，实现和esp8266的通信。
stm32和esp8266之一最简单驱动
08-04
stm32和esp8266之一最简单驱动,仅仅通过串口使用，最简单驱动esp8266。只有驱动哦。
Stm32+Esp8266连接阿里云程序移植教程（MQTT协议）
最新发布
m0_58326153的博客
10-13 1217
把esp8266连接阿里云的程序移植到自己的工程中，移植简单，使用方便！！！
Esp8266程序基于STM32
11-07
正如所题,基于STM32的ESP8266 WIF程序开发,可以正常执行的代码
STM32+正点原子ESP8266
weixin_51358957的博客
01-26 1741
使用STM32F103C8T6串口3连接正点原子ESP8266模块，实现单片机和原子云通信（移植正点原子例程）
STM32+ESP8266实现物联网
05-05
使用STM32F407与ESP8266通讯，ESP8266连接互联网，通过互联网对继电器进行控制
STM32外设系列—ESP8266（WIFI）
qq_45217381的博客
07-05 2万+
本文介绍了ESP8266固件库烧录方法。常用AT指令。介绍了利用ESP8266访问心知天气API并解析天气数据的方法，并且给出了详细的程序设计。
STM32-连接wifi模块(esp8266)
热门推荐
jx5631833的博客
08-18 2万+
乐鑫智能互联平台——ESP8266 拥有高性能无线 SOC，是一个完整且自成体系的 WiFi 网络解决方案，能够独立运行，也可以作为 slave 搭载于其他 Host 运行。
学习素材之USART篇——通过使用STM32与ESP8266（esp-01s）连接阿里云系列操作来了解USART协议和寄存器操作
玄奕子的博客
04-07 1万+
通过使用STM32与ESP8266（esp-01s）连接阿里云系列操作来了解USART协议和寄存器操作
STM32+ESP8266物联网硬件电路图（PCB）
05-05
该文档是STM32+ESP8266控制继电器的硬件电路图和PCB，可以通过互联网远程实现对继电器的控制。
esp8266和stm32驱动之三实现访问网站获取数据
10-16
esp8266和stm32驱动, 可以连接路由器，然后访问网站，获取网站上面的数据显示处理啊，相关问题代码里面有介绍怎么操作。
stm32+esp8266连web服务器
06-01
stm32+esp8266连web服务器stm32+esp8266连web服务器stm32+esp8266连web服务器stm32+esp8266连web服务器stm32+esp8266连web服务器stm32+esp8266连web服务器stm32+esp8266连web服务器stm32+esp8266连web服务器stm32+...
stm32_esp8266.rar_DHT11 STM32F103_STM32 8266_STM32+ESP8266+DHT11
07-15
标题中的"stm32_esp8266.rar_DHT11 STM32F103_STM32 8266_STM32+ESP8266+DHT11"揭示了这个项目的核心组成部分：STM32微控制器（具体型号为STM32F103）、DHT11温湿度传感器以及ESP8266 WiFi模块。这个压缩包可能包含...
STM32+ESP8266+MQTT协议连接阿里云物联网平台
04-22
使用stm32，ESP8266WiFi数据传输，mqtt协议，阿里云物联网平台，程序源码，下载可用。附app应用。 使用stm32，ESP8266WiFi数据传输，mqtt协议，阿里云物联网平台，程序源码，下载可用。附app应用。 使用stm32，ESP...
stm32+esp8266-WiFi收发json数据
02-28
STM32与ESP8266的组合在物联网应用中非常常见，它们可以协同工作，实现设备通过WiFi进行数据通信。在这个项目中，STM32（STM32F103C8T6）作为主控器，负责处理较低级别的控制任务，而ESP8266则作为一个低成本、低...
STM32+ESP8266连阿里云
07-30
这通常涉及到使用STM32的串行通信接口（如UART）来与ESP8266建立连接。STM32固件的开发可以使用如Keil uVision或IAR Embedded Workbench等IDE，编写代码时需包含STM32的HAL库，以简化底层硬件操作。 在STM32与ESP...
STM32 HAL库+ESP8266+机智云
qq_51967985的博客
11-30 3742
最近在项目中需要使用云平台对接，于是在网上查找了一些资料，发现机智云是一个不错的选择，网上的资料多，而且可以根据mcu生成通信协议代码，仅需要将生成的代码移植到开发好的项目中，即可实现上云。不过在实际开发中，仍然遇到了一些问题，所以在此处将我的开发心得记录下来。到此，整个工程代码已经移植完毕，但是现在的代码只是一个框架，我们还没有去写接收处理函数和发送函数其实这两个函数，在上面的代码中已经完成，我们只需要在相关的代码中填写上我们需要传输的数据即可。
stm32c8t6hal库esp8266串口
06-02
STM32C8T6HAL库是针对STM32C8T6芯片进行开发的一套HAL库，提供了丰富的外设驱动和底层硬件操作接口。而ESP8266是一款WiFi模块，可以通过串口通信与STM32芯片进行通信。在使用ESP8266模块时，可以使用STM32的串口功能来进行通信。 在使用STM32C8T6HAL库与ESP8266模块进行串口通信时，需要先配置好串口参数（如波特率、数据位、停止位、校验位等），然后通过HAL库提供的函数来进行发送和接收数据。具体步骤如下： 1. 在HAL库中初始化串口功能，设置好串口参数。 2. 在代码中写好发送和接收数据的函数。 3. 在主程序中调用发送和接收数据的函数，实现与ESP8266模块的通信。 具体实现过程可以参考以下代码示例： ```c #include "stm32c8t6_hal.h" // 定义串口变量 UART_HandleTypeDef huart1; // 定义接收缓存区和计数器 uint8_t rx_buffer[256]; uint8_t rx_counter = 0; // 发送数据函数 void send_data(uint8_t* data, uint16_t len) { HAL_UART_Transmit(&huart1, data, len, 1000); } // 接收数据回调函数 void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) { if (huart->Instance == USART1) { // 将接收到的数据存入缓存区 rx_buffer[rx_counter++] = huart->Instance->DR; // 如果缓存区满了，清空计数器 if (rx_counter >= 256) { rx_counter = 0; } // 继续接收数据 HAL_UART_Receive_IT(&huart1, &rx_buffer[rx_counter], 1); } } int main(void) { // 初始化串口1 huart1.Instance = USART1; huart1.Init.BaudRate = 115200; huart1.Init.WordLength = UART_WORDLENGTH_8B; huart1.Init.StopBits = UART_STOPBITS_1; huart1.Init.Parity = UART_PARITY_NONE; huart1.Init.Mode = UART_MODE_TX_RX; huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart1.Init.OverSampling = UART_OVERSAMPLING_16; HAL_UART_Init(&huart1); // 开启中断接收 HAL_UART_Receive_IT(&huart1, &rx_buffer[rx_counter], 1); // 发送数据给ESP8266模块 uint8_t send_data[] = "AT+RST\r\n"; send_data(send_data, sizeof(send_data)); // 接收ESP8266模块返回的数据 while (1) { if (rx_counter > 0) { // 处理接收到的数据 // ... // 清空缓存区 rx_counter = 0; memset(rx_buffer, 0, sizeof(rx_buffer)); // 继续接收数据 HAL_UART_Receive_IT(&huart1, &rx_buffer[rx_counter], 1); } } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值