串口透传
“透传”通常指的是数据的透明传输，意思是在不对数据进行任何处理或修改的情况下，将数据从一个接口转发到另一个接口。
值得注意的是要避免串口之间无限制的透明，可以采用互斥锁的方式进行限制
使用方法
对USART1和USART3(用他俩举例)的模式都是设置为Asynchronous，并开启对应的中断。
RCC的High SPeed CLock模式设置为Crystal/Ceramic
配置对应的时钟为64Mhz
在main函数中启动串口1和串口3的空闲中断模式，接收数据 HAL_UARTEx_ReceiveToIdle_IT(&huart1, rxbuf1, sizeof(rxbuf1));
HAL_UARTEx_ReceiveToIdle_IT(&huart3, rxbuf3, sizeof(rxbuf3));
在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）设备中。
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调试软件
————————————————
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
原文链接：https://blog.csdn.net/m0_51830537/article/details/142152090
|
|
楼主
标题置顶
标题高亮
