UART.c

#include "stm32f1xx_it.h"
#include "LED.h"
#include "UART.h"
#include "string.h"

UART_HandleTypeDef huart1;
UART_HandleTypeDef huart3;

#define RXBUFFERSIZE 4096 //最大接收字节数

char RxBuffer1[RXBUFFERSIZE]; //接收数据
uint8_t aRxBuffer1; //接收中断缓冲
uint32_t Uart1_Rx_Cnt = 0; //接收缓冲计数

char RxBuffer3[RXBUFFERSIZE]; //接收数据
uint8_t aRxBuffer3; //接收中断缓冲
uint32_t Uart3_Rx_Cnt = 0; //接收缓冲计数

/**
* @brief USART1 Initialization Function
* @param None
* @retval None
*/
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();
}
/* USER CODE BEGIN USART1_Init 2 */
HAL_UART_MspInit(&huart1);
HAL_UART_Receive_IT(&huart1, (uint8_t *)&aRxBuffer1, 1); //开启接收中断
/* USER CODE END USART1_Init 2 */
}

/**
* @brief USART3 Initialization Function
* @param None
* @retval None
*/
void MX_USART3_UART_Init(void)
{
/* USER CODE BEGIN USART3_Init 0 */

/* USER CODE END USART3_Init 0 */

/* USER CODE BEGIN USART3_Init 1 */

/* USER CODE END USART3_Init 1 */
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 */
HAL_UART_MspInit(&huart3);
HAL_UART_Receive_IT(&huart3, (uint8_t *)&aRxBuffer3, 1); //再开启接收中断
/* USER CODE END USART3_Init 2 */
}

/**
* @brief This function is executed in case of error occurrence.
* @retval None
*/
void Error_Handler(void)
{
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
__disable_irq();
while (1){}
/* USER CODE END Error_Handler_Debug */
}

void send_to_Usart3(char * cmd){
HAL_UART_Transmit(&huart3, (uint8_t *)cmd,strlen(cmd),0xFFFF);
while(HAL_UART_GetState(&huart3) == HAL_UART_STATE_BUSY_TX);//检测UART发送结束
}

void show_Usart3_Message(){
HAL_UART_Transmit(&huart1, (uint8_t *)&RxBuffer3, Uart3_Rx_Cnt,0xFFFF); //将收到的信息发送出去
while(HAL_UART_GetState(&huart1) == HAL_UART_STATE_BUSY_TX);//检测UART发送结束
Uart3_Rx_Cnt = 0;
memset(RxBuffer3,0x00,sizeof(RxBuffer3)); //清空数组
}

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart){
if(huart->Instance==USART1){
if(Uart1_Rx_Cnt >= (RXBUFFERSIZE-1)){ //溢出判断
Uart1_Rx_Cnt = 0;
memset(RxBuffer1,0x00,sizeof(RxBuffer1));
HAL_UART_Transmit(&huart1, (uint8_t *)"数据溢出", 10,0xFFFF);
}else{
RxBuffer1[Uart1_Rx_Cnt++] = aRxBuffer1; //接收数据转存
//HAL_UART_Transmit(&huart3, (uint8_t *)test, sizeof(test),0xFFFF);

        /\*  
        if((RxBuffer1\[Uart1\_Rx\_Cnt-1\] == 0x0A)&&(RxBuffer1\[Uart1\_Rx\_Cnt-2\] == 0x0D)){ //判断结束位  
            HAL\_UART\_Transmit(&huart3, (uint8\_t \*)&RxBuffer1, Uart1\_Rx\_Cnt,0xFFFF); //将收到的信息发送出去  
            while(HAL\_UART\_GetState(&huart3) == HAL\_UART\_STATE\_BUSY\_TX);//检测UART发送结束  
            Uart1\_Rx\_Cnt = 0;  
            memset(RxBuffer1,0x00,sizeof(RxBuffer1)); //清空数组  
        }  
        \*/  
    }  
    HAL\_UART\_Receive\_IT(&huart1, (uint8\_t \*)&aRxBuffer1, 1);   //再开启接收中断  
}  
if(huart->Instance==USART3){  
    if(Uart3\_Rx\_Cnt >= (RXBUFFERSIZE-1)){  //溢出判断  
        Uart3\_Rx\_Cnt = 0;  
        memset(RxBuffer3,0x00,sizeof(RxBuffer3));  
        HAL\_UART\_Transmit(&huart1, (uint8\_t \*)"数据溢出", 10,0xFFFF);  
    }else{  
        RxBuffer3\[Uart3\_Rx\_Cnt++\] = aRxBuffer3;   //接收数据转存  
        /\*  
        if(((RxBuffer3\[Uart3\_Rx\_Cnt-1\] == 0x0A)&&(RxBuffer3\[Uart3\_Rx\_Cnt-2\] == 0x0D))){ //判断结束位  
            HAL\_UART\_Transmit(&huart1, (uint8\_t \*)&RxBuffer3, Uart3\_Rx\_Cnt,0xFFFF); //将收到的信息发送出去  
            while(HAL\_UART\_GetState(&huart1) == HAL\_UART\_STATE\_BUSY\_TX);//检测UART发送结束  
            Uart3\_Rx\_Cnt = 0;  
            memset(RxBuffer3,0x00,sizeof(RxBuffer3)); //清空数组  
        }  
        \*/  
    }  
    HAL\_UART\_Receive\_IT(&huart3, (uint8\_t \*)&aRxBuffer3, 1);   //再开启接收中断  
}  

}

//重定向c库函数printf到串口DEBUG_USART，重定向后可使用printf函数
int fputc(int ch, FILE *f){
/* 发送一个字节数据到串口DEBUG_USART */
HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 1000);
return (ch);
}

main.c

/**
* @brief The application entry point.
* @retval int
*/
int main(void)
{
/* USER CODE BEGIN 1 */

/* USER CODE END 1 */

/* MCU Configuration--------------------------------------------------------*/

/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();

/* USER CODE BEGIN Init */

/* USER CODE END Init */

/* Configure the system clock */
SystemClock_Config();
/* USER CODE BEGIN SysInit */

/* USER CODE END SysInit */

/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_USART1_UART_Init();
MX_USART3_UART_Init();
/* USER CODE BEGIN 2 */
LED_GPIO_Config();
esp8266_Init();
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
//unsigned char hello[]="hello\n\r";
//HAL_UART_Transmit(&huart1,hello,sizeof(hello),0x10);
HAL_Delay(2000);
show_Usart3_Message();

char cmd1\[\]="AT+CWLAP\\r\\n";  
send\_to\_Usart3(cmd1);  
HAL\_Delay(10000);  
show\_Usart3\_Message();

char cmd2\[\]="AT+CWJAP=\\"Redmi K30\\",\\"lpnb6666\\"\\r\\n";  
send\_to\_Usart3(cmd2);  
HAL\_Delay(20000);  
show\_Usart3\_Message();

char cmd4\[\]="AT+CIPMUX=0\\r\\n";  
send\_to\_Usart3(cmd4);  
HAL\_Delay(3000);  
show\_Usart3\_Message();

char cmd5\[\]="AT+CIPMODE=1\\r\\n";  
send\_to\_Usart3(cmd5);  
HAL\_Delay(3000);  
show\_Usart3\_Message();

char cmd3\[\]="AT+CIFSR\\r\\n";  
send\_to\_Usart3(cmd3);  
HAL\_Delay(3000);  
show\_Usart3\_Message();

send\_to\_Usart3("AT+CIPSTART=\\"TCP\\",\\"192.168.43.193\\",8899\\r\\n");  
HAL\_Delay(10000);  
show\_Usart3\_Message();

send\_to\_Usart3("AT+CIPSEND\\r\\n");  
HAL\_Delay(3000);  
show\_Usart3\_Message();

send\_to\_Usart3(">\\r\\n");  
HAL\_Delay(3000);  
show\_Usart3\_Message();

send\_to\_Usart3("lp\\r\\n");  
HAL\_Delay(3000);  
show\_Usart3\_Message();

send\_to\_Usart3("123456\\r\\n");  
HAL\_Delay(3000);  
show\_Usart3\_Message();

send\_to\_Usart3("hello everyone\\r\\n");  
HAL\_Delay(3000);  
show\_Usart3\_Message();

send\_to\_Usart3("+++");  
HAL\_Delay(3000);  
show\_Usart3\_Message();  

while (1)
{
send_to_Usart3("AT\r\n");
HAL_Delay(1000);
show_Usart3_Message();
}
/* USER CODE END 3 */
}

注意事项：

首先，不能连续 发AT+指令，需要等上一个指令处理完再发下一个指令，具体怎么等可以用AT指令查询

其次，不能直接用C库接收，要使用串口中断接收

再次，发送给esp8266模块的数据要以\r\n结尾，数据透传用>\r\n开始，用+++结束，其中+++没有\r\n