STM32F407模拟串口实现

STM32F407模拟串口实现
一、背景

最近做一个项目，需要用STM32F407来做7路串口通信，由于芯片最多只有6路，所以只能用IO口来模拟串口通信。在网上查找了很多模拟串口的资料，决定串口发送采用延时的方式，串口接收采用外部中断+定时器中断来实现。外部中断检测第一次检测下降沿表明接收到了起始位，通过定时器中断定时检测接收IO口上的电平，从而判断接收的是0还是1.

二、正文

1）、串口发送：

由于串口发送的函数比较简单，所以先从发送开始做起，首先咱们来熟悉一下串口协议，1位起始位+8位数据位+1位奇偶校验位+1位停止位（其中停止位可能为0.5位,1位,1.5位或2位，可以选择）。串口异步传输在空闲状态时都必须是高电平。

由于现在是模拟串口，暂时不考虑复杂的奇偶校验位，所以采用的格式为：1位起始位+8位数据位+1位奇偶校验位+1位停止位。项目需要采用的波特率为115200，所以每发送1bit数据需要的时间：1/115200=8.68us.

模拟串口发送发送函数：
```
 1 #define COM1_TX_PORT   GPIOA
 2 
 3 #define COM1_TX_PIN    GPIO_Pin_9
 4 
 5 void Virtual_Uart_Bytesend(u8 val)
 6 
 7 {
 8 
 9 u8 i=0;
10 
11 COM1_TX_DATA_LOW();  // 起始位，低电平，IO口初始化时应该置为高电平
12 
13 delay_us(baudRate);
14 
15     for(i = 0;i<8;i++)          // 8位数据位
16 
17 {
18 
19     if (val & 0x01)
20 
21 {
22 
23     COM1_TX_DATA_HIGH();
24 
25 }
26 
27 else
28 
29 {
30 
31     COM1_TX_DATA_LOW();
32 
33 }
34 
35 delay_us(baudRate);
36 
37 val >>= 1;
38 
39 }
40 
41 COM1_TX_DATA_HIGH();    // 停止位 高电平
42 
43 delay_us(baudRate);
44 
45 }
```
以上代码完全是根据协议的格式来写的，思路很简单，里面最重要的一个参数是这个baundRate;这个参数根据不同的波特率而不同，并且实际值和理论值算出来的时间可能有些差别，调试发现STM32F4的误差比较小，基本上理论值和实际值一样就可以正常通信。波特率为115200，延时理论上为8.68us。但是问题就来了，STM32F407例程delay.c里给的延时函数最小单位为us,设置baundRate=8或者9通信偶尔能够正常接收，但是很多时候是乱码，如下图：

如何解决这一问题呢，首先想到是设计一个延时0.1us或者更小的延时函数来实现，需要了解SRM32F4的时钟部分，这部分暂时没有去研究

第二种方法：采用nop来延时+滴答定时器定时8s

也就是用定时器定时8s,然后在加上nop指令延时，然后实际调试用一个for循环增加4个nop指令左右就能正常接收。具体延时函数实现如下：
```
 1 // 模拟串口延时函数 波特率为115200 所以延时8.68us
 2 
 3 void Vuart_delay_us(void)
 4 
 5 {
 6 
 7 u16 i = 0;
 8 
 9 u32 temp;       
10 
11 SysTick->LOAD=8*fac_us; //时间加载     
12 
13 SysTick->VAL=0x00;         //清空计数器
14 
15 SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ; //开始倒数   
16 
17 do
18 
19 {
20 
21 temp=SysTick->CTRL;
22 
23 }while((temp&0x01)&&!(temp&(1<<16))); //等待时间到达   
24 
25 SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk; //关闭计数器
26 
27 SysTick->VAL =0X00;        //清空计数器 
28 
29 for (i = 0;i<4;i++)
30 
31 {
32 
33 __NOP;
34 
35 }
36 
37 }
```
实验现象如下图所示：

主函数中调用串口发送函数。
```
 1 // 发送一个字符串
 2 
 3 void Virtual_Uart1_StringSend(u8 *str)
 4 
 5 {
 6 
 7 while(*str != 0)
 8 
 9 {
10 
11 Virtual_Uart1_Bytesend(*str);
12 
13 str++;
14 
15 }
16 
17 }
```
2）、串口接收

串口接收比较复杂，暂未研究。

以上的串口接收对实现1模拟串口还可以，但是项目需要用的2个或者更多的模拟串口就不适合了，需要更改一下思路，开辟一个新的定时器，定时器的优先级需要开到最高，定时1/（波特率*3倍）s，这里波特率设置为115200，所以定时时间为2.89us,波特率越高对定时器的要求就越高，幸好STM32F407非常强大，这么高的串口波特率需要定时至少2us左右才能实现模拟串口的正常通信。基本思路分为接收和发送。

接收时：定时器定时去扫描IO口的状态，当3次里面检测到有至少2次低电平时，则判断该电平为低电平。首先是设计定时器定时0.289us,参考原子的官方定时器中断例程，定时函数如下：

TIM3_Int_Init(5000-1,8400-1); // 定时器时钟84M，分频系数8400，所以84M/8400=10Khz的计数频率，计数5000次为500ms

更改为

TIM3_Int_Init(242,1-1); //定时器时钟84M，分频系数1，所以84M/1=84Mhz的计数频率，计数242次为2.89us

不分频时，如果计数1次则定时的时间为1/84MHz=0.0119us，所以将计数值更改为242，则定时时间=1/84MHz * 242 = 2.88us

定时器初始化函数在主函数初始化时候调用，值得注意的是定时器的优先级应该设置为最高，即修改定时初始化函数如下：

NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0x00; // 抢占优先级0 优先级设置为最高

NVIC_InitStructure.NVIC_IRQChannelSubPriority=0x00;          // 子优先级0    优先级设置为最高

设计好定时器之后，接下来是设计一个8位数据接收函数，主要思路是通过一个状态机、定时计数变量（计数三次表示8.6us）、高电平计数变量和低电平计数变量（分别用于三次采样里面有几次是能踩到高电平或者低电平）。

变量定义如下：

static u32 recvStat = COM_STOP_BIT; // 定义状态机

static u8 recvData = 0;               // 定义一个接收数据变量

static u32 timer_cnt = 0;             // 定时总次数

static u32 high_cnt = 0;              // 高电平检测次数

static u32 low_cnt = 0;             // 低电平检测次数

状态机定义在头文件中：

enum{

COM_START_BIT, //起始位

COM_D0_BIT, //bit0

COM_D1_BIT, //bit1

COM_D2_BIT, //bit2

COM_D3_BIT, //bit3

COM_D4_BIT, //bit4

COM_D5_BIT, //bit5

COM_D6_BIT, //bit6

COM_D7_BIT, //bit7

COM_STOP_BIT,   //bit8

};

//定义接收引脚

#define COM1_RX_DATA   GPIO_ReadInputDataBit(COM1_RX_PORT,COM1_RX_PIN) // 接收引脚

具体函数实现如下：
```
  1 // 接收一个8位数据
  2 
  3 void Virtual_Uart1_Byterecived(void)
  4 
  5 {
  6 
  7 timer_cnt++;
  8 
  9 if((COM1_RX_DATA == 0)&&(recvStat == COM_STOP_BIT))  // 起始信号
 10 
 11 { low_cnt++;
 12 
 13     if (timer_cnt >= 3)
 14 
 15 {
 16 
 17 timer_cnt=0;
 18 
 19 if (low_cnt>1)
 20 
 21 {   
 22 
 23 recvStat = COM_START_BIT;
 24 
 25 }
 26 
 27 low_cnt=0;
 28 
 29 }
 30 
 31  return;
 32 
 33 }
 34 
 35 if(timer_cnt >= 3)
 36 
 37 {  if(recvStat < COM_STOP_BIT)
 38 
 39         recvStat++;
 40 
 41 }
 42 
 43 if((recvStat == COM_STOP_BIT)&&(COM1_RX_DATA == 1))  // 空闲时，计数值清0
 44 
 45 {
 46 
 47     timer_cnt = 0;
 48 
 49 high_cnt=0;
 50 
 51 low_cnt=0;
 52 
 53 return;
 54 
 55 }
 56 
 57 if(COM1_RX_DATA == 0)
 58 
 59 {
 60 
 61     low_cnt++;
 62 
 63 high_cnt=0;
 64 
 65 if (timer_cnt >= 3)
 66 
 67 {
 68 
 69 timer_cnt=0;
 70 
 71 if (low_cnt>1)  // 3次采样里面是否有两次有效
 72 
 73 {
 74 
 75 recvData &= ~(1 <<(recvStat - 1));
 76 
 77 }
 78 
 79 low_cnt=0;
 80 
 81 }
 82 
 83 }
 84 
 85 else
 86 
 87 {
 88 
 89     high_cnt++;
 90 
 91 low_cnt=0;
 92 
 93 if (timer_cnt >= 3)
 94 
 95 {
 96 
 97 timer_cnt=0;
 98 
 99 if (high_cnt>1)  // 3次采样里面是否有两次有效
100 
101 {
102 
103 recvData |= (1 <<(recvStat - 1));
104 
105 }
106 
107 high_cnt=0;
108 
109 }
110 
111 }
112 
113 }
```
实验现象如下：

发送：发送思路比接收更简单，只要按照串口的协议来发送即可。首先是发送起始位，3个定时器周期后发送八位数据位，最后发送停止位。源代码如下：
```
  1 // 串口发送函数
  2 
  3 void Virtual_Uart1_Bytesend(void)
  4 
  5 {
  6 
  7 if (txdEnable == 0)
  8 
  9 {
 10 
 11     Tx_timer_cnt = 0;
 12 
 13 return;
 14 
 15 }
 16 
 17 Tx_timer_cnt++;
 18 
 19 if ((txdStat == COM_STOP_BIT)&&(txdEnable == 1))
 20 
 21 {
 22 
 23 COM1_TX_DATA_LOW();
 24 
 25     if (Tx_timer_cnt >= 3)
 26 
 27 {
 28 
 29 Tx_timer_cnt=0;
 30 
 31 txdStat = COM_START_BIT;
 32 
 33 txdData = Tx_Buf[Txd_Bytes];
 34 
 35 }
 36 
 37 }
 38 
 39 else if(txdStat == COM_D7_BIT)
 40 
 41 {
 42 
 43 COM1_TX_DATA_HIGH();
 44 
 45     if (Tx_timer_cnt >= 3)
 46 
 47 {
 48 
 49 Tx_timer_cnt=0;
 50 
 51 txdStat = COM_STOP_BIT;
 52 
 53 Txd_Bytes++;
 54 
 55 if(Txd_Bytes>3)  // 测试发送三个字节
 56 
 57 {
 58 
 59 Txd_Bytes = 0;
 60 
 61     txdEnable = 0;
 62 
 63 }
 64 
 65 }
 66 
 67 }
 68 
 69 else
 70 
 71 {     
 72 
 73 if (txdData & 0x01)
 74 
 75 {
 76 
 77     COM1_TX_DATA_HIGH();
 78 
 79 }
 80 
 81 else
 82 
 83 {
 84 
 85     COM1_TX_DATA_LOW();
 86 
 87 }
 88 
 89 if (Tx_timer_cnt >= 3)
 90 
 91 {
 92 
 93 Tx_timer_cnt=0;
 94 
 95 txdData >>= 1;
 96 
 97 txdStat++;
 98 
 99 }
100 
101 }
102 
103 }
```
实验现象，串口每隔1s发送四个字节的数据1234，如下图所示

以上基本实现了模拟串口数据的发送和接收，可能有很多地方可以优化，后续会更新。

记录时间：2017年7月19日13:49:12

记录地点：XH
相关阅读:
Spring Boot 整合 Apache Ignite
QuantumTunnel：Netty实现
 QuantumTunnel：内网穿透服务设计
 Java虚拟机
 LeetCode
Java线程如何返回数据
 Java动态代理简单应用
 Java反射机制浅析
 数据结构之Heap (Java)
JUnit4单元测试基础篇
原文地址：https://www.cnblogs.com/zengxy/p/7205363.html