STM32F767 采用FIFO模式串口发送接收

smallerlang

已于 2022-12-01 20:58:56 修改

阅读量883

点赞数 2

分类专栏： STM32 文章标签： stm32 单片机物联网

于 2021-08-06 19:23:25 首次发布

本文链接：https://blog.csdn.net/smallerlang/article/details/119461921

版权

STM32 专栏收录该内容

149 篇文章 14 订阅

订阅专栏

功能：将接收到的数据发送出去

UART_HandleTypeDef huart1;
/**
  * @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();
  /* USER CODE BEGIN 2 */
	

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /*检测到FIFO中有数据则发送*/
    Uart_Transmit(&huart1); 
  }
  /* USER CODE END 3 */
}

#ifndef __BSP_USART_H
#define __BSP_USART_H

#ifdef __cplusplus
extern "C" {
#endif
	
#include "stm32f7xx_hal.h"
#include "fifo.h"

extern uint8_t Uart_RxData;
extern FIFO Uart_Fifo;
	
void Uart_Transmit(UART_HandleTypeDef *huart); 

#ifdef __cplusplus
}
#endif

#endif /* __BSP_USART_H */

#include "bsp_usart.h"

uint8_t Uart_RxData;
FIFO Uart_Fifo;

/**
  * @brief 检测到FIFO中有数据则发送
  * @param None
  * @retval None
  */
void Uart_Transmit(UART_HandleTypeDef *huart)
{
	uint8_t val;
	
	/*判断FIFO里面是否有要发送的数据*/
	
	{
		/*判断发送数据寄存器是否为空*/
		if(__HAL_UART_GET_FLAG(huart, UART_FLAG_TXE) == SET)
		{
			/*将数据写入发送数据寄存器*/
			if(ReadFIFO(&Uart_Fifo, &val))
			{
				huart->Instance->TDR = val;
			}
		}
	}
}

/**
  * @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;
  huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */
	
	HAL_UART_Receive_IT(&huart1, &Uart_RxData, 1);

  /* USER CODE END USART1_Init 2 */

}

/**
* @brief UART MSP Initialization
* This function configures the hardware resources used in this example
* @param huart: UART handle pointer
* @retval None
*/
void HAL_UART_MspInit(UART_HandleTypeDef* huart)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(huart->Instance==USART1)
  {
  /* USER CODE BEGIN USART1_MspInit 0 */

  /* USER CODE END USART1_MspInit 0 */
    /* Peripheral clock enable */
    __HAL_RCC_USART1_CLK_ENABLE();

    __HAL_RCC_GPIOA_CLK_ENABLE();
    /**USART1 GPIO Configuration
    PA9     ------> USART1_TX
    PA10     ------> USART1_RX
    */
    GPIO_InitStruct.Pin = GPIO_PIN_9|GPIO_PIN_10;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    /* USART1 interrupt Init */
    HAL_NVIC_SetPriority(USART1_IRQn, 3, 0);
    HAL_NVIC_EnableIRQ(USART1_IRQn);
  /* USER CODE BEGIN USART1_MspInit 1 */

  /* USER CODE END USART1_MspInit 1 */
  }

}

/**
  * @brief This function handles USART1 global interrupt.
  */
void USART1_IRQHandler(void)
{
  /* USER CODE BEGIN USART1_IRQn 0 */

  /* USER CODE END USART1_IRQn 0 */
  HAL_UART_IRQHandler(&huart1); 
  /* USER CODE BEGIN USART1_IRQn 1 */

  /* USER CODE END USART1_IRQn 1 */
}

/* USER CODE BEGIN 1 */

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	//if(huart == &huart1)
	if(huart->Instance == USART1)
	{
		WriteFIFO(&Uart_Fifo, Uart_RxData); 
		HAL_UART_Receive_IT(&huart1, &Uart_RxData, 1);
	}
}

#ifndef __FIFO_H
#define __FIFO_H

#ifdef __cplusplus
extern "C" {
#endif

#include "stm32f7xx_hal.h"
	
#define FIFO_SIZE 		256		/* 取2的n次方*/

typedef struct
{	
	uint8_t pData[FIFO_SIZE];			// 数据缓冲区，最大256
	uint8_t wr, rd;			// 读写索引: 指针重合时为空, 最多存(bufferSize - 1)个字节
} FIFO;

uint8_t WriteFIFO(FIFO *buf, uint8_t v);
uint8_t ReadFIFO(FIFO *buf, uint8_t *v);
void ClearFIFO(FIFO *buf);

#ifdef __cplusplus
}
#endif

#endif /* __FIFO_H */

#include "fifo.h"
#include <string.h>

/**
  * @brief 向FIFO写入一个字节, 成功返回1, 失败返回0
  * @param None
  * @retval None
  */
uint8_t WriteFIFO(FIFO *buf, uint8_t v)
{
	uint8_t ret = 0;
	if(((buf->wr + 1) & (FIFO_SIZE - 1)) != buf->rd)	// 是否已满?
	{
		buf->pData[buf->wr] = v;
		buf->wr = (buf->wr + 1) & (FIFO_SIZE - 1);
		ret = 1;		// 成功写入
	}
	else
	{
		ret = 0;
	}
	return ret;
}

/**
  * @brief 从FIFO读取一个字节, 成功返回1, 失败返回0
  * @param None
  * @retval None
  */
uint8_t ReadFIFO(FIFO *buf, uint8_t *v)
{
	uint8_t ret = 0;
	if(buf->wr != buf->rd)	// 是否为空?
	{
		*v = buf->pData[buf->rd];
		buf->rd = (buf->rd + 1) & (FIFO_SIZE - 1);
		ret = 1;		// 成功读出
	}
	return ret;
}

/**
  * @brief 清除缓冲区
  * @param None
  * @retval None
  */
void ClearFIFO(FIFO *buf)
{	
	memset(buf->pData, 0, FIFO_SIZE);
	
	buf->rd = 0;
	buf->wr = 0;
}