UART工作原理    UART即通用异步收发器，是一种串行通信方式。数据在传输过程中是通过一位一位地进行传输来实现通信的，串行通信方式具有传输线少，成本底等优点，缺点是速度慢。串行通信分为两种类型：同步通信方式和异步通信方式。   
. W# ?! a/ a1 |但一般多用异步通信方式，主要因为接受和发送的时钟是可以独立的这样有利于增加发送与接收的灵活性。异步通信是一个字符接着一个字符传输，一个字符的信息由起始位、数据位、奇偶校验位和停止位组成。   
' H: T+ {! @8 G8 o( y, G每一个字符的传输靠起始位来同步，字符的前面一位是起始位，用下降沿通知收方开始传输，紧接着起始位之后的是数据位，传输时低位在前高位在后，字符本身由5～8位数据位组成。   
0 F  w1 l: B% h/ ~! V数据位后面是奇偶校验位，最后是停止位，停止位是用高电平来标记一个字符的结束，并为下一个字符的传输做准备。停止位后面是不同长度的空闲位。停止位和空闲位都规定为高电平，这样可以保证起始位有一个下降沿。   
6 E% @. i$ S) R' C* v& @1 Y% I
5 [1 Q2 T6 B. e/ [$ `0 [
* \& B% B9 e# P9 F1 v( K/ _7 AUART的帧格式如图：



! _2 |" ]! c" d+ g+ i
9 ?& j' }2 Z4 @8 \( A; w8 w! t# m
1 c" d3 H! V7 A    UART的帧格式包括线路空闲状态（idle，高电平）、起始位（start bit，低电平）、5～8位数据位（data bits）、校验位（parity bit，可选）和停止位（stop bit，位数可为1、1.5、2位）。  
# _1 M5 b4 G% T# j: o+ H! l3 o8 N" V
# p, t1 h& C2 @' c
4 Z* ^5 V$ d* J3 i: }: U- i3 j$ i& kUART模拟原理   
& W1 I( t5 X7 Y: E& HUART的模拟方式基本就是定时器+IO口实现。


方案1：只打印不接收

    如果在实际使用中只是为了打印log而不接收数据，可以采用DWT加普通IO口的方式；

1. #define  VCOM_BOUND     115200
   : a$ B" }0 w; z  j) ?8 y
2. #define  VCOM_PIN       GPIO_Pin_11
   
3. #define  VCOM_PORT      GPIOA
   ; h: g0 t) v$ G: S
4. #define  VCOM_PIN_HIGH  VCOM_PORT->BSRR = VCOM_PIN
   
5. #define  VCOM_PIN_LOW   VCOM_PORT->BRR  = VCOM_PIN
   
6. 
   
7. #define  BSP_REG_DEM_CR                           (*(volatile unsigned int *)0xE000EDFC) //DEMCR寄存器
   
8. #define  BSP_REG_DWT_CR                           (*(volatile unsigned int *)0xE0001000)   //DWT控制寄存器
   
9. #define  BSP_REG_DWT_CYCCNT                       (*(volatile unsigned int *)0xE0001004) //DWT时钟计数寄存器
   
10. #define  BSP_REG_DBGMCU_CR                        (*(volatile unsigned int *)0xE0042004)
    5 C' k( C" X3 r3 ]
11. 
    
12. #define  DEF_BIT_00                               0x01u
    ( u& E) r0 g4 x. x
13. #define  DEF_BIT_24                               0x01000000u
    
14. #define  BSP_BIT_DEM_CR_TRCENA                    DEF_BIT_24   
    
15. #define  BSP_BIT_DWT_CR_CYCCNTENA                 DEF_BIT_00
    9 |5 {7 F3 k+ ^" T* i3 n' {7 J  T
16. static unsigned int  sys_clock = 48000000;
    2 C2 n; h" _: f6 f/ I& N
17. 
    & Y  X. o0 |/ B& x& A
18. inline void dwt_start(void)
    
19. {
    
20. BSP_REG_DEM_CR     |= (unsigned int)BSP_BIT_DEM_CR_TRCENA;
    
21.     BSP_REG_DWT_CYCCNT  = (unsigned int)0u;            //初始化CYCCNT寄存器
    
22.     BSP_REG_DWT_CR     |= (unsigned int)BSP_BIT_DWT_CR_CYCCNTENA;    //开启CYCCNT
    , L6 W* x  I$ `
23. }
    
24. 
    " T0 C  g$ d) `, Z/ _
25. inline void dwt_stop(void)
    ) d& V; V6 i6 a
26. {
    + |, p, K6 k+ d; _- A
27. BSP_REG_DWT_CR = 0;
    # z$ }* L% Q$ j% S( G* k4 e
28. }
    3 @" J5 \/ c# s: b( `
29. 
    . I/ d! G+ _9 `+ W" r8 Y  y8 C5 l
30. void vcom_pin_init(void)
    * _% U# N; c7 p- v; H
31. {
    
32.     GPIO_InitTypeDef GPIO_InitStructure;
    % \; c% n) b; }6 x
33.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    
34.     GPIO_InitStructure.GPIO_Pin   = VCOM_PIN;
    ) I' d% k, l" F7 ]  i
35.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    & m8 Z0 \6 S; H/ f4 s
36.     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_Out_PP;
    * Q! w6 L! u6 n" L. J& }
37.     GPIO_Init(VCOM_PORT, &GPIO_InitStructure);
    ( }8 }1 z* x/ M" ]6 P; I; r
38.     GPIO_SetBits(VCOM_PORT,VCOM_PIN);
    
39. VCOM_PIN_HIGH;
    
40. }
    . E1 N% ^; }( w
41. 
    
42. void vcom_put_char(char ch)
    4 R: e: J: b+ t
43. {
    ' T; E& `% r0 `  |, m
44. int i;
    7 x6 E* o. J) M( Y# X2 _! v& y' g
45. int dat[8];
    
46. uint32_t sys_clk, bit_width;
    ! u- D+ n3 D1 M3 h( e/ ]
47. volatile uint32_t time_stamp;
    
48. 
      Z8 h4 d# _& }
49.     sys_clk = sys_clock/1000000;  
    
50.     bit_width = 1000000*sys_clk/VCOM_BOUND;
    & ?5 L4 Q) k% {) e
51.     for(i=0; i<8; i++)           
    
52.     {
    0 U/ o" P4 n" }0 h; _8 ?: y* R
53.         if(ch & 0x01)
    8 B9 w' n  H# h1 X
54.             dat[i] = 1;
    $ q) A& Q3 \8 u( F
55.         else
    ' s5 c" o0 z# f) C; S' t
56.             dat[i] = 0;
    % T) H; H& d7 z* l$ c. C8 ^2 a, b
57.         ch >>= 1;
    
58.     }
    % m4 c% l$ Y) m2 d
59.     OS_CPU_SR cpu_sr;
    
60.     enter_critical();//以下代码进行临界保护,防止被中断打断造成发送误码
    
61.     dwt_start();
    
62.     VCOM_PIN_LOW; //发送起始位
    ' C% J  M& G* E
63. time_stamp = BSP_REG_DWT_CYCCNT;
    
64. while(BSP_REG_DWT_CYCCNT < (time_stamp+bit_width))；
    * V3 k4 q, ?" k& M$ ^+ A
65. for(i=0; i<8; i++)
    + A1 C' M( |7 w) w( u( W" l
66. {
    : `0 ^  g8 V$ D$ g
67.   if(dat[i])
    
68.    VCOM_PIN_HIGH;
    , @, q* }' r: N* F' Y( B
69.   else
    3 L* o9 {( A4 _
70.    VCOM_PIN_LOW;
      H9 |! \2 i5 [# X3 i
71.   time_stamp = BSP_REG_DWT_CYCCNT;
    
72.   while(BSP_REG_DWT_CYCCNT < (time_stamp+bit_width)); //发8bit 数据位
    
73. }
    + z% b5 ^9 s2 f
74. VCOM_PIN_HIGH;
    " ?! p+ O8 v2 ?7 V! [
75. time_stamp = BSP_REG_DWT_CYCCNT;
    " h2 N- X7 }# d' Y+ F
76. while(BSP_REG_DWT_CYCCNT < (time_stamp+bit_width));     //发停止位
    
77. dwt_stop();
    
78. exit_critical();
    ' p& d6 _" S& O* ?+ ]
79. }
    
80. 
    ) u: w% ^2 z4 F
81. void vcom_printf(const char *fmt, ...)
    3 K6 f) C/ e0 M5 U
82. {
    " A& d1 H3 V0 C1 @$ ~
83.     char buf[0x80];
    + {: q; ]8 N1 `9 L# q
84.     int  i;
    
85.     va_list ap;
    2 z" @8 f1 A) W2 }* J+ ]4 V2 K! x9 h
86. memset(buf, 0x00, sizeof(buf));
    
87.     va_start(ap, fmt);
    
88.     vsnprintf(buf, sizeof(buf), fmt, ap);
      e& r7 _% y, d
89.     va_end(ap);
    
90. 
    
91. i = 0;
    
92. while(buf[i])
    , c+ o$ u$ V2 s; r4 w
93. {
    # z# S, V$ |7 _8 Q. L
94.   vcom_put_char(buf[i]);
    
95.   i++;
    
96. }
    
97. }

复制代码

方案2：半双工UART

    实现方式: 普通定时器+普通IO口中断+fifo

1. 
   
2. /**
   % S- p  O* j5 I: ?
3. *软件串口的实现(IO模拟串口)
   : S  r. H- W1 {3 O0 Y, [
4. * 波特率：9600    1-8-N
   + K! e2 L9 f2 Z  P  I1 ?  X0 Z
5. * TXD : PC13
   
6. * RXD : PB14
   
7. * 使用外部中断对RXD的下降沿进行触发，使用定时器4按照9600波特率进行定时数据接收。
   ! e- W0 G" O1 M) C5 Z
8. * Demo功能: 接收11个数据，然后把接收到的数据发送出去
   
9. */
   
10. 
    
11. 
    
12. #define OI_TXD PCout(13)
    
13. #define OI_RXD PBin(14)
    & I1 p! m6 o9 y' E4 `0 @6 Z; |
14. 
    
15. #define BuadRate_9600 100
    - X5 c$ k- Y# [
16. 
    # y6 J1 D* A6 Z# h' v
17. u8 len = 0; //接收计数
    
18. u8 USART_buf[11];  //接收缓冲区
    
19. 
    
20. enum{
    $ l* r3 x; a& b+ t% Z4 w
21. COM_START_BIT,
    . @5 k0 J2 C$ g2 K( q5 E0 c
22. COM_D0_BIT,
    1 L5 g, B! w/ T5 t( U
23. COM_D1_BIT,
    . x" J8 I8 R  |5 f
24. COM_D2_BIT,
    
25. COM_D3_BIT,
    
26. COM_D4_BIT,
    ! x* r* L9 w9 `* D3 R- p
27. COM_D5_BIT,
    
28. COM_D6_BIT,
    8 Y4 F) g' G: q! Q1 @  n5 M
29. COM_D7_BIT,
    
30. COM_STOP_BIT,
    
31. };
    & H" o" D; x' [# }+ M
32. 
    
33. u8 recvStat = COM_STOP_BIT;
    ; s4 C8 ?1 \$ S" f! h/ ]% }0 p0 }# n
34. u8 recvData = 0;
    ) |  d. m( _! C3 z  K3 l
35. 
    
36. void IO_TXD(u8 Data)
    
37. {
    - }# E. P. s! Y( k
38. u8 i = 0;
    
39. OI_TXD = 0;  
    
40. delay_us(BuadRate_9600);
    
41. for(i = 0; i < 8; i++)
    & ~3 l: i" N, ]
42. {
    
43.   if(Data&0x01)
    
44.    OI_TXD = 1;  
    
45.   else
    7 K% R$ }. W& {
46.    OI_TXD = 0;  
    
47.   
    ) ~9 {6 Q! G8 e
48.   delay_us(BuadRate_9600);
    - q( R( k) [( I2 r1 Y7 K
49.   Data = Data>>1;
    $ f2 L# g% }) R5 @* I* Z
50. }
      X6 P$ ^& U' X- F3 X& p
51. OI_TXD = 1;
    7 U" @! [0 |( a4 {( ^
52. delay_us(BuadRate_9600);
    " }# m! `) F$ N* Q# F( |8 `, y
53. }
    
54. 
    
55. void USART_Send(u8 *buf, u8 len)
    4 ~* c% l) k$ ^1 `& @
56. {
    2 L7 a+ ^6 Q& L: i4 L: v3 g6 L
57. u8 t;
    / |" I6 _+ ^3 }& S1 D' w2 Z" w' U
58. for(t = 0; t < len; t++)
    
59. {
    , X8 p# [4 l1 H
60.   IO_TXD(buf[t]);
    - ~# O" @, U" J+ p4 q
61. }
    
62. }
    
63. 
      e! E" S% ~5 S3 E
64. void IOConfig(void)
    
65. {
    5 \7 h# N# R9 [+ B# F$ ^! g
66. GPIO_InitTypeDef  GPIO_InitStructure;
    
67. NVIC_InitTypeDef NVIC_InitStructure;
      H- m9 G$ T7 |' K+ j4 a0 J4 s
68. EXTI_InitTypeDef EXTI_InitStruct;
      b, @8 A5 j( m$ o# C* C
69. RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO|RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOC, ENABLE);  //使能PB,PC端口时钟
    
70. 
    
71. //SoftWare Serial TXD
    
72. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;     
    % h* r2 b2 H4 h0 x
73. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;    //推挽输出
    3 [7 n3 S; b1 A9 h. e( m/ U" y
74. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;   //IO口速度为50MHz  
    
75. GPIO_Init(GPIOC, &GPIO_InitStructure);      
    % S7 O( d& v/ N1 b# S. M- n
76. GPIO_SetBits(GPIOC,GPIO_Pin_13);      
    ! w" B& V  b+ C% P/ S& f$ n
77.   
    7 H; Z* s; n& m( s
78.   
    
79. //SoftWare Serial RXD
    
80. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;
    
81. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    
82. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;  
    
83. GPIO_Init(GPIOB, &GPIO_InitStructure);  
    / C% U+ r* F' U5 V
84. 
    , g' u& A; s, m6 S' \- G7 i
85. GPIO_EXTILineConfig(GPIO_PortSourceGPIOB, GPIO_PinSource14);
    
86. EXTI_InitStruct.EXTI_Line = EXTI_Line14;
    
87. EXTI_InitStruct.EXTI_Mode=EXTI_Mode_Interrupt;
    9 r; B9 }7 B& I' H, P4 c0 j2 k
88. EXTI_InitStruct.EXTI_Trigger=EXTI_Trigger_Falling; //下降沿触发中断
    
89. EXTI_InitStruct.EXTI_LineCmd=ENABLE;
    
90. EXTI_Init(&EXTI_InitStruct);
    ) o9 }. \$ r2 ]4 C+ \
91. 
    & F3 r4 m. p% J; L- T
92. NVIC_InitStructure.NVIC_IRQChannel= EXTI15_10_IRQn ;
    
93. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2;
      N/ Q. e( B/ Z; W
94. NVIC_InitStructure.NVIC_IRQChannelSubPriority =2;  
    
95. NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;  
    
96. NVIC_Init(&NVIC_InitStructure);  
    
97. 
    
98. }
    
99. 
    + q" r  k- H( Y0 D6 u( e
100. void TIM4_Int_Init(u16 arr,u16 psc)
     
101. {
     
102. TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
     ! w6 ?  F, a: H* P% T8 R
103. NVIC_InitTypeDef NVIC_InitStructure;
     
104. 
     " j/ a+ }/ \3 P0 ~6 v
105. RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE); //时钟使能
     ' [5 m" m( y# [3 D, ]+ M5 S: o! E
106. 
     
107. //定时器TIM4初始化
     ( ]* F6 @/ w9 a; U  Z- J1 T
108. TIM_TimeBaseStructure.TIM_Period = arr; //设置在下一个更新事件装入活动的自动重装载寄存器周期的值
     ' m0 E( C$ U9 L( A# `7 U
109. TIM_TimeBaseStructure.TIM_Prescaler =psc; //设置用来作为TIMx时钟频率除数的预分频值
     
110. TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; //设置时钟分割:TDTS = Tck_tim
     
111. TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式
     
112. TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure); //根据指定的参数初始化TIMx的时间基数单位
     . s, k4 I: n2 t! Z+ L6 U, H+ i- C
113. TIM_ClearITPendingBit(TIM4, TIM_FLAG_Update);
     8 X1 z% y+ g8 A* w1 L. \$ P8 D
114. TIM_ITConfig(TIM4,TIM_IT_Update,ENABLE ); //使能指定的TIM3中断,允许更新中断
     8 E1 v# \- q" U
115. 
     4 Y9 t& _& K7 E8 l& I" F
116. //中断优先级NVIC设置
     , q8 x* q5 K" }/ ^
117. NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn;  //TIM4中断
     
118. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;  //先占优先级1级
     6 X0 e. s+ f& ^8 P/ {2 Y2 S
119. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;  //从优先级1级
     
120. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道被使能
     
121. NVIC_Init(&NVIC_InitStructure);  //初始化NVIC寄存器   
     
122. }
     
123. 
     
124. 
     1 K2 u) }3 M" P# i0 @4 M: I9 K0 i! A' v7 R
125. int main(void)
     % \1 `5 \. l" V) n- I' N. a; n
126. {  
     + d; R" j. m. ]  U0 x8 {4 X
127. NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置中断优先级分组为组2：2位抢占优先级，2位响应优先级
     
128. delay_init();
     - Q* C* Y6 o5 |8 M; t3 M
129. IOConfig();
     
130. TIM4_Int_Init(107, 71);  //1M计数频率
     
131. 
     ' z* {: {( Z2 _! ^! X- |
132. while(1)
     
133. {
     
134.   if(len > 10)
     
135.   {
     
136.    len = 0;
     
137.    USART_Send(USART_buf,11);
     + \7 |. e& F# b7 _
138.   }
     
139. }
     ; p  D9 `4 N5 W. C7 {/ r/ A1 G. |
140. }
     
141. 
     $ M& P( e! X+ @+ ?
142. void EXTI15_10_IRQHandler(void)
     
143. {
     5 t' b; E/ L  h1 ~% }& M+ s; E
144. if(EXTI_GetFlagStatus(EXTI_Line14) != RESET)
     
145. {
     5 `& x% u- J  M/ X, ?
146.   if(OI_RXD == 0)
     & q8 D9 P! D. y1 w$ S3 r
147.   {
     
148.    if(recvStat == COM_STOP_BIT)
     & H# ^% Y3 x! D% \( ~
149.    {
     
150.     recvStat = COM_START_BIT;
     
151.     TIM_Cmd(TIM4, ENABLE);
     
152.    }
     
153.   }
     
154.   EXTI_ClearITPendingBit(EXTI_Line14);
     
155. }
     
156. }
     
157. 
     
158. void TIM4_IRQHandler(void)
     
159. {  
     
160. if(TIM_GetFlagStatus(TIM4, TIM_FLAG_Update) != RESET)
       j! I7 f# o2 {
161. {
     
162.   TIM_ClearITPendingBit(TIM4, TIM_FLAG_Update);
     7 ?0 E2 V3 B) d0 T
163.   recvStat++;
     & [+ [$ c) ]2 J$ M! b( }
164.   if(recvStat == COM_STOP_BIT)
     + c4 k% O) }" @, x1 R
165.   {
     0 Y9 F. m) e; o) N/ U% d+ y6 r- }
166.    TIM_Cmd(TIM4, DISABLE);
     1 j8 c& v* t! \3 u! d. ?
167.    USART_buf[len++] = recvData;
     
168.    return;
     
169.   }
     . J* R6 H, i5 g5 W; i
170.   if(OI_RXD)
     
171.   {
     $ W" J3 U4 f3 t
172.    recvData |= (1 << (recvStat - 1));
     8 }" L1 t  f7 ?. T( @2 t: p! Y
173.   }else{
     
174.    recvData &= ~(1 << (recvStat - 1));
     
175.   }
     % D$ p2 h7 c" g& z7 v( z
176. }  
     5 d1 Y7 t7 k- u- v9 E% b
177. }

复制代码

( j7 ]) [. Y2 W6 n

转载自：玩转单片机与嵌入式

如有侵权请联系删除

! A7 F! {/ G& V
7 \, T. x. V6 ?2 L$ H9 M; W