STM32 GPIO模拟UART串口：最简延时方式

2023-05-16

STM32 GPIO模拟UART串口：最简延时方式

在一些应用场景，MCU的硬件UART资源不足时，或者可用于硬件UART配置的管脚优先配置给了其它功能使用，就可以通过GPIO模拟UART功能以获得串口支持。本文介绍基于延时方式的实现，除了TX和RX两个GPIO管脚，不需要用到其它MCU资源。延时的实现需要用到微秒延时函数，参考 STM32 HAL us delay（微秒延时）的指令延时实现方式及优化。

这里以STM32F401CCU6芯片，STM32CUBEIDE开发平台实现模拟UART的范例。范例的UART通讯协议采用最常用的配置，即一个起始位，8个数据位，一个停止位，波特率为9600bps，码宽为104us。如果需要扩展高级功能，可以基于范例的基本实现进行修改。

字节发送过程，通过微秒延时控制按周期进行位的发送，对应的GPIO配置为push-pull输出，默认输出高电平。
字节接收过程，通过将接收管脚设置为下降沿触发中断，从而在第一个下降沿到来时识别为接收开始，然后通过微秒延时控制，在1.5个周期时接收第一个位，随后都在1个周期延时接收后续的位。在接收到停止位时进行数据处理和后续接收准备。

范例的工程设计为回环测试。RX管脚接收到一个字节后，TX管脚将这个字节发出去。

工程配置

首先建立基本工程配置，设置时钟系统：
在这里插入图片描述

然后选择一对GPIO作为模拟UART的TX和RX管脚。这里用PA0作为TX, PA1作为RX（下降沿中断模式）。

并使能PA1的下降沿中断响应：

保存并生成基本工程代码：

代码实现

接收过程和发送过程都要进行状态控制以识别和控制空闲态和工作态，接收管脚接收到第一个下降沿中断时会识别为接收开始，后续接收数据过程中也会有下降沿中断接收到，但不会做处理，而是在周期延时控制下进行数据位的接收，接收完一个字节之后，后续来的下降沿才会识别为新的数据接收开始。

完整的main.c代码如下：

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2022 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
//Written by Pegasus Yu in 2022
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
__IO float usDelayBase;
void PY_usDelayTest(void)
{
  __IO uint32_t firstms, secondms;
  __IO uint32_t counter = 0;

  firstms = HAL_GetTick()+1;
  secondms = firstms+1;

  while(uwTick!=firstms) ;

  while(uwTick!=secondms) counter++;

  usDelayBase = ((float)counter)/1000;
}

void PY_Delay_us_t(uint32_t Delay)
{
  __IO uint32_t delayReg;
  __IO uint32_t usNum = (uint32_t)(Delay*usDelayBase);

  delayReg = 0;
  while(delayReg!=usNum) delayReg++;
}

void PY_usDelayOptimize(void)
{
  __IO uint32_t firstms, secondms;
  __IO float coe = 1.0;

  firstms = HAL_GetTick();
  PY_Delay_us_t(1000000) ;
  secondms = HAL_GetTick();

  coe = ((float)1000)/(secondms-firstms);
  usDelayBase = coe*usDelayBase;
}


void PY_Delay_us(uint32_t Delay)
{
  __IO uint32_t delayReg;

  __IO uint32_t msNum = Delay/1000;
  __IO uint32_t usNum = (uint32_t)((Delay%1000)*usDelayBase);

  if(msNum>0) HAL_Delay(msNum);

  delayReg = 0;
  while(delayReg!=usNum) delayReg++;
}
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
#define GPIO_OUTPUT_EXEC_DELAY_us 8
#define BaudRate_us 104 //for 9600bps
#define RD HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1);
#define TDL HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_RESET)
#define TDH HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_SET)
/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */
#define buff_len 256
uint8_t tx_status = 0;
uint8_t rx_status = 0;

uint8_t txd[buff_len];
uint8_t rxd[buff_len];

uint32_t txd_index=0;
uint32_t rxd_index=0;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */
  uint8_t bytebit;
  /* 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();
  /* USER CODE BEGIN 2 */
  PY_usDelayTest();
  PY_usDelayOptimize();

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
	  switch(rx_status)
	  {

	  case 1:{//bit 1
		     rxd[rxd_index] = 0;
             PY_Delay_us_t(1.5*BaudRate_us);
             bytebit = RD;
             (bytebit==0)?(rxd[rxd_index]>>=1):(rxd[rxd_index]=(rxd[rxd_index]>>1)|0x80);
             rx_status ++;
	         }
	  case 2:{//bit 2
             PY_Delay_us_t(BaudRate_us);
             bytebit = RD;
             (bytebit==0)?(rxd[rxd_index]>>=1):(rxd[rxd_index]=(rxd[rxd_index]>>1)|0x80);
             rx_status ++;
	         }
	  case 3:{//bit 3
             PY_Delay_us_t(BaudRate_us);
             bytebit = RD;
             (bytebit==0)?(rxd[rxd_index]>>=1):(rxd[rxd_index]=(rxd[rxd_index]>>1)|0x80);
             rx_status ++;
	         }
	  case 4:{//bit 4
             PY_Delay_us_t(BaudRate_us);
             bytebit = RD;
             (bytebit==0)?(rxd[rxd_index]>>=1):(rxd[rxd_index]=(rxd[rxd_index]>>1)|0x80);
             rx_status ++;
	         }
	  case 5:{//bit 5
             PY_Delay_us_t(BaudRate_us);
             bytebit = RD;
             (bytebit==0)?(rxd[rxd_index]>>=1):(rxd[rxd_index]=(rxd[rxd_index]>>1)|0x80);
             rx_status ++;
	         }
	  case 6:{//bit 6
             PY_Delay_us_t(BaudRate_us);
             bytebit = RD;
             (bytebit==0)?(rxd[rxd_index]>>=1):(rxd[rxd_index]=(rxd[rxd_index]>>1)|0x80);
             rx_status ++;
	         }
	  case 7:{//bit 7
             PY_Delay_us_t(BaudRate_us);
             bytebit = RD;
             (bytebit==0)?(rxd[rxd_index]>>=1):(rxd[rxd_index]=(rxd[rxd_index]>>1)|0x80);
             rx_status ++;
	         }
	  case 8:{//bit 8
             PY_Delay_us_t(BaudRate_us);
             bytebit = RD;
             (bytebit==0)?(rxd[rxd_index]>>=1):(rxd[rxd_index]=(rxd[rxd_index]>>1)|0x80);
             rx_status ++;
	         }
	  case 9:{//stop bit
             PY_Delay_us_t(BaudRate_us);
             bytebit = RD;
             if(bytebit==1)
             {
                 tx_status = 1; //Sending enable for loop-back test
                 bytebit = rxd[rxd_index];

            	 if(rxd_index==(buff_len-1)) rxd_index=0;
            	 else rxd_index++;

             }

             rx_status = 0;
		     break;
	         }

	  default:break;
	  }

	  switch(tx_status)
	  {

	  case 1:{//start bit
             TDL;
             PY_Delay_us_t(BaudRate_us-GPIO_OUTPUT_EXEC_DELAY_us);
             tx_status ++;
	         }
	  case 2:{//bit 1
             if((bytebit&0x01)==0) TDL;
             else TDH;
             PY_Delay_us_t(BaudRate_us-GPIO_OUTPUT_EXEC_DELAY_us);
             bytebit >>= 1;
             tx_status ++;
	         }
	  case 3:{//bit 2
             if((bytebit&0x01)==0) TDL;
             else TDH;
             PY_Delay_us_t(BaudRate_us-GPIO_OUTPUT_EXEC_DELAY_us);
             bytebit >>= 1;
             tx_status ++;
	         }
	  case 4:{//bit 3
             if((bytebit&0x01)==0) TDL;
             else TDH;
             PY_Delay_us_t(BaudRate_us-GPIO_OUTPUT_EXEC_DELAY_us);
             bytebit >>= 1;
             tx_status ++;
	         }
	  case 5:{//bit 4
             if((bytebit&0x01)==0) TDL;
             else TDH;
             PY_Delay_us_t(BaudRate_us-GPIO_OUTPUT_EXEC_DELAY_us);
             bytebit >>= 1;
             tx_status ++;
	         }
	  case 6:{//bit 5
             if((bytebit&0x01)==0) TDL;
             else TDH;
             PY_Delay_us_t(BaudRate_us-GPIO_OUTPUT_EXEC_DELAY_us);
             bytebit >>= 1;
             tx_status ++;
	         }
	  case 7:{//bit 6
             if((bytebit&0x01)==0) TDL;
             else TDH;
             PY_Delay_us_t(BaudRate_us-GPIO_OUTPUT_EXEC_DELAY_us);
             bytebit >>= 1;
             tx_status ++;
	         }
	  case 8:{//bit 7
             if((bytebit&0x01)==0) TDL;
             else TDH;
             PY_Delay_us_t(BaudRate_us-GPIO_OUTPUT_EXEC_DELAY_us);
             bytebit >>= 1;
             tx_status ++;
	         }
	  case 9:{//bit 8
             if((bytebit&0x01)==0) TDL;
             else TDH;
             PY_Delay_us_t(BaudRate_us-GPIO_OUTPUT_EXEC_DELAY_us);
             tx_status ++;
	         }
	  case 10:{//stop bit
             TDH;
             PY_Delay_us_t(BaudRate_us-GPIO_OUTPUT_EXEC_DELAY_us);
             tx_status = 0;
	         }
	  default:break;
	  }
    /* 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};

  /** Configure the main internal regulator output voltage
  */
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE2);

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLM = 16;
  RCC_OscInitStruct.PLL.PLLN = 336;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV4;
  RCC_OscInitStruct.PLL.PLLQ = 4;
  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 GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOA_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_SET);

  /*Configure GPIO pin : PA0 */
  GPIO_InitStruct.Pin = GPIO_PIN_0;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /*Configure GPIO pin : PA1 */
  GPIO_InitStruct.Pin = GPIO_PIN_1;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /* EXTI interrupt init*/
  HAL_NVIC_SetPriority(EXTI1_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(EXTI1_IRQn);

}

/* USER CODE BEGIN 4 */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{

  if(GPIO_Pin==GPIO_PIN_1)
  {
	if(rx_status==0) rx_status = 1;  //get falling edge of start bit
  }
}
/* USER CODE END 4 */

/**
  * @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 */
}

#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 */

注意事项

本范例采用自然指令延时实现UART收发，在接收完整个字节或发送完整个字节前不能被打断，否则时序不准会出错。所以本范例方式适用于不会同时进行收发的场景。
本范例实现环回测试，通过PC连接MCU后可以发送单个字节并接收到回送的字节。不能同时发2个字节以上，因为收到第一个字节后就开始回传，如果有第二个以上的字节接收，则如上所述会产生时序冲突。当然，通过具体的协议控制，修改程序，可以控制程序在接收到符合条件/数目的字节后才开始处理如回送，则一次接收到的串口数据不受限制。
要实现能够同时进行收发的模拟UART功能，提高鲁棒性，则需要用到TIM定时器资源。可参阅 STM32 GPIO模拟UART串口：外部时钟及TIM方式。

测试效果

通过串口工具向例程芯片发送数据，得到回送的数据：
在这里插入图片描述
再发送一次单字节

例程下载

STM32 GPIO模拟UART串口：最简延时方式例程下载

–End–

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)