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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432

注意事项

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

测试效果

通过串口工具向例程芯片发送数据，得到回送的数据：

再发送一次单字节

例程下载

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

–End–