前言% \# k+ ]7 D& P8 g" V$ k* l) f
本篇用库函数写个简单的串口收发,用的是 STM32F103RCT6 开发板(部分来自正点原子)。! k2 ?& P5 I m/ K
STM32F103RCT6 最多可提供 5 路串口,有分数波特率发生器、支持同步单线通信和半双工
, x' c% [& J7 [9 u单线通讯、支持 LIN、支持调制解调器操作、智能卡协议和 IrDA SIR ENDEC 规范、具有 DMA
9 G: X. `1 i8 L1 O) o( p' E0 n等。% q* {% I( e0 ~5 j2 }! ] h! {. t3 _
% h" q. B9 \% \6 b1 d串口设置的一般步骤可以总结为如下几个步骤:
. Z) ?$ V( c* _- L! X; R8 Q3 _) [) z/ Z" o6 Y
串口时钟使能,GPIO 时钟使能8 F* D8 d! E; Q/ x- S. Y g" `" c
串口复位
; O. S$ n3 o- z# s. q# c: ^4 mGPIO 端口模式设置
9 n" K4 X" h" J, I( a( X3 y串口参数初始化4 ?( y( o1 z, k! B6 C3 z1 m ~
开启中断并且初始化 NVIC(如果需要开启中断才需要这个步骤)* B! _) }6 w( {( P. L A1 t( S/ m
使能串口# Q. D# c( \3 E1 ^% c7 ^6 U: \
编写中断处理函数
. k z& n- k( ]% f @% ^一、串口配置步骤
0 |9 r I& J- y+ ], ~7 B0 n6 C( E- |函数和定义主要分布在 stm32f10x_usart.h 和 stm32f10x_usart.c 文件中。
! P- S5 E$ x/ X1 Q# M" L8 k, _
: U8 \( p8 }+ L" X- S+ y/ J* ?1.串口时钟使能 串口是挂载在 APB2 下面的外设,所以使能函数为:: G6 f$ z( p$ G5 S( T5 D. F
) o; B. B& }- [4 T; Q+ h6 A3 E6 Y' M
- RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1);
复制代码 ; N8 s* l% p) W. Y3 I
2.串口复位 当外设出现异常的时候可以通过复位设置,实现该外设的复位,然后重新配置
8 m: t$ [5 ~' \# q, f, p, {这个外设达到让其重新工作的目的。
! X( B! U. e* T+ S5 K* K/ N复位的是在函数 USART_DeInit()中完成:$ L* M( C6 j. T+ i3 n
0 C+ `. P0 r* G# G! F% J8 L
- void USART_DeInit(USART_TypeDef* USARTx);//串口复位
复制代码 4 `! _7 v* u) `4 f) m* J2 q
复位串口 1,方法为:- USART_DeInit(USART1); //复位串口 1
复制代码 ( p7 z' T" W; w
3.串口参数初始化 串口初始化是通过 USART_Init()函数实现的,' F" B3 |7 ]# k3 I. v k# L1 F/ u
1 _6 y7 d9 y( N S% D5 C- void USART_Init(USART_TypeDef* USARTx, USART_InitTypeDef* USART_InitStruct);
复制代码 # g/ e8 X( U6 y" \9 H
第二个入口参数是USART_InitTypeDef 类型的结构体指针,这个结构体指针的成员变量用; h% _6 `, p3 \5 k* y. }- q0 e
来设置串口的一些参数。' s* E" G3 m L) {
一般的实现格式为:- USART_InitStructure.USART_BaudRate = bound; //波特率;& P& K2 t' m. W. N: j$ S
- USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为 8 位数据格式
! V$ m* o/ k( m$ A$ V - USART_InitStructure.USART_StopBits = USART_StopBits_1; //一个停止位
! Q0 I& Y A' w( T3 E3 G2 d! h- j - USART_InitStructure.USART_Parity = USART_Parity_No; //无奇偶校验位/ X& @% c+ T) H' m! s" j2 m
- USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; //无硬件数据流控制
( [4 i r* X. q, w" T- u - USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //收发模式
4 l: _, m9 u, j9 w; w8 d" g - USART_Init(USART1, &USART_InitStructure); //初始化串口
复制代码
/ _3 _0 V: f" J1 U" W4.数据发送与接收 STM32 的发送与接收是通过数据寄存器 USART_DR 来实现的,这是: @% d6 g* V- T/ v+ [
一个双寄存器,包含了 TDR 和 RDR。当向该寄存器写数据的时候,串口就会自动发送,当收
$ m- x$ d$ [! k到收据的时候,也是存在该寄存器内。) e; }8 @9 l+ l# F
STM32 库函数操作 USART_DR 寄存器发送数据的函数是:
- e, c% ?- s" n$ ^0 i9 f- d3 ?
) K/ X. r k) P. F ~, k6 D6 w- void USART_SendData(USART_TypeDef* USARTx, uint16_t Data);
复制代码
" N5 w) e* {( S7 b: USTM32 库函数操作 USART_DR 寄存器读取串口接收到的数据的函数是:- uint16_t USART_ReceiveData(USART_TypeDef* USARTx);
复制代码
: S5 p" g6 g, r. ]5 F% h3 o6.串口使能 串口使能是通过函数 USART_Cmd()来实现的
! I5 D+ W0 u6 A1 ?& W% n9 o- r4 ]; P! J" m8 G
- USART_Cmd(USART1, ENABLE); //使能串口
复制代码 " W$ J8 X5 e' f
7.开启串口响应中断 使能串口中断的函数是:- void USART_ITConfig(USART_TypeDef* USARTx, uint16_t USART_IT, FunctionalState NewState)
复制代码 , ~' C1 Y+ P5 o* ~4 p* r+ S4 @. M& b
开启其中之一的中断的方法是:- L% k# F# {: m; d
1 j8 T B, y3 `3 J9 A- o- USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启中断,接收到数据中断
复制代码 . k& n- W3 [; W8 S9 o1 E
发送数据结束的时候要产生中断:* m) F) }* V% k7 J5 D# d' u, o
3 P c" J* u0 I- USART_ITConfig(USART1,USART_IT_TC,ENABLE);
复制代码
7 x; M" P. N n# M$ |8.获取相应中断状态 在中断处理函数中,要判断该中断是哪种中断,使用的函数是:
2 `' @. u. i6 g, L% O. n3 E6 i5 s/ {) b U. l/ H% J( j# ^
- ITStatus USART_GetITStatus(USART_TypeDef* USARTx, uint16_t USART_IT)
复制代码 - J, a' i) q* I+ I! j' J& [9 F
判断是否是串口发送完成中断:$ [' u8 p% ~. [" c) h2 P( V; H. r
2 W, ?$ x- y- t
- USART_GetITStatus(USART1, USART_IT_TC)
复制代码
% h: L1 e: Y6 b; R7 R返回值是 SET,说明是串口发送完成中断发生。+ s: a7 @; I& Q: }. h9 U( s
3 z6 S" T0 w5 K7 m3 c! ^
二、实际编写' J, d0 j0 t5 `; T( W6 d" Q% T
1.代码部分
. g$ a4 j+ G+ e——uart.c 文件
6 J7 R, z3 M8 |9 z, y* e
) G3 h# B0 t% L$ |" i p( [①重定向fputc函数. u4 U9 G4 n5 A2 s: n! s. w
使用串口1(USART1)输出Printf信息, p* H- o/ j, ]# X7 l4 _1 m
3 G% L: ~- p$ |# r/ r0 r; W* }- #if 1 , ~7 m1 h# |) l8 D$ o) o) L b. d
- #pragma import(__use_no_semihosting) $ H& r, W$ i. B' j- j$ T3 N! @
- //标准库需要的支持函数 4 U4 `) a H+ F
- struct __FILE
& b" m! |1 u8 ]/ K. O. ] - { 0 n7 D" ]5 ? o* l3 X
- int handle;
4 G: P: p. e8 i/ v7 G6 Z" C - /* Whatever you require here. If the only file you are using is */ 5 O0 K5 F+ ~# n0 }# i/ S& q
- /* standard output using printf() for debugging, no file handling */
( |# Q2 q9 N8 X) v; S/ Y) ~- S - /* is required. */ S) j# _* W! h. a
- }; % F1 g0 @ s n8 m$ ~
- /* FILE is typedef’ d in stdio.h. */
; D) ]7 F: P8 r2 E$ l - FILE __stdout; & n" t f- N: r- a0 N2 Y
- //定义_sys_exit()以避免使用半主机模式
5 J: p6 M/ s$ @ - void _sys_exit(int x) 8 }( b ]1 _" ]7 L' g7 T# \3 v) k- _
- { " o# g0 F5 Z; s, ?6 i( f* o- g/ r% @
- x = x; ( `, @- w; Q1 `
- } . a* G' x" x; d2 u
- //重定向fputc函数
! D+ N+ v' I, q - //printf的输出,指向fputc,由fputc输出到串口
/ V8 A% q3 G- x' S6 c1 b* z - //这里使用串口1(USART1)输出printf信息 6 q& a+ r W( O- [5 t/ J$ M% b, q) V( g
- int fputc(int ch, FILE *f) + ^0 ~+ y; }/ e9 w8 {& c4 Y: y
- {
* V* s+ d! N! H7 _9 C1 W - while((USART1->SR&0X40)==0);//循环发送,直到发送完毕 3 L2 s! a7 r$ x9 V
- USART1->DR = (u8) ch;
' W: X! Z1 j8 @& I: N - return ch;
\% g/ ?" P- ^- l6 \4 o8 E - }
* Y3 q' Q# y1 M3 H7 M0 j - #endif
复制代码 4 Z. U! z6 m! c8 \
②GPIO
# C( }) W" e1 h- u8 USART_RX_BUF[USART_REC_LEN] __attribute__ ((at(0X20001000)));
! _' t% H5 L+ [; r- E' K - //接收缓冲,最大USART_REC_LEN个字节,起始地址为0X20001000.* f. O! Y' e8 y1 `( N3 r& k
- u16 USART_RX_STA=0; //接收状态标记 6 W2 r: [9 N1 b. Q( d# L( Z
- u16 USART_RX_CNT=0; //接收的字节数
复制代码- void uart_init(u32 bound){! i9 f: A/ X) {0 Y2 V
- //GPIO端口设置(初始化)
& _3 x% s2 ?( _. B# Z3 {; | - GPIO_InitTypeDef GPIO_InitStructure;
?" v% ^0 [9 V7 g" S- ?! }, V - USART_InitTypeDef USART_InitStructure;
& t6 y S4 O* l1 Z) G- n& d - NVIC_InitTypeDef NVIC_InitStructure;- x5 I: E# Q: S4 I5 b
-
. _3 }) G, R0 w2 i! J, ^ - RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);
7 W q% |! s+ r1 |1 N - //使能USART1,GPIOA时钟
" `, T2 Y5 c) u+ G
& k( @8 H f+ m6 @" p) y% Q1 j: V- //USART1_TX GPIOA.9+ l+ ~1 r2 O& `) Q6 L
- GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.92 d: k$ E6 E1 K% m# w. R
- GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
* m0 M$ A8 Z( c, {6 ^: Q - GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出( q7 d1 b- z- e: ]. Y" B
- GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9% A# z% c6 }7 [
- / ~" M9 ^+ O7 |2 w2 b! z
- //USART1_RX GPIOA.10初始化$ \) O7 U, Y+ m# W$ V) h' d3 d
- GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
7 z% s6 ?+ m3 M; [! ~7 t% J - GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入! T/ u, @9 _2 [+ Q
- GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10
! ?! r# [+ \2 }- W - ; t$ p- o/ {( C' s+ H+ @
- //Usart1 NVIC 配置. i1 h! V6 J5 R* _9 h3 k" u' A
- NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
8 i5 T. q% i# s& s. v8 p3 ] - NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
0 H* K/ o2 d* B) S& J- g - NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; //子优先级3& m% h' E9 e, W
- NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能
# K( x! R$ H2 C0 f1 ~, _8 a - NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化VIC寄存器. u# [7 S: }! B% e1 U4 P
" g/ ~- I; B/ X2 L$ ~ m) }9 P- //USART 初始化设置0 @5 J/ p1 l- l8 ?( N/ ^
6 a$ J+ r. \# m$ _- USART_InitStructure.USART_BaudRate = bound;//串口波特率* L7 e% p' c$ q
- USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式: \% X8 U* |9 Q' \# F' s
- USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
/ g8 i7 i4 ]! J# d; L, M - USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位# M* ^4 _, Z1 m5 B1 [
- USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制$ M3 J* T7 b9 {* p+ g
- USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //收发模式
- A) d4 v }. L. E - ; i8 i4 H! l& w
- USART_Init(USART1, &USART_InitStructure); //初始化串口16 A B" x6 k* T
- USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
! v$ F5 W$ C% _: T - USART_Cmd(USART1, ENABLE); //使能串口1
! B$ F4 ^ P" O: }6 c - 1 J+ S* \5 W1 Z) C2 Z4 E1 J+ a
- }
复制代码- #if EN_USART1_RX //如果使能了接收% H* E0 w6 N8 P6 N8 k
- void USART1_IRQHandler(void) //串口1中断服务程序
* g; U4 p- x: n0 h8 h" `) W8 R - {
' O# R; @6 b$ L5 M( U5 z - u8 Res;
' h: X( W9 ~8 @, s - #if SYSTEM_SUPPORT_OS //如果SYSTEM_SUPPORT_OS为真,则需要支持OS.
) _" h( ?2 c# n% r - OSIntEnter(); * r8 Z; ]/ e; _( _) q
- #endif$ p# k2 \" x+ z
- if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) //接收中断(接收到的数据必须是0x0d 0x0a结尾)% I/ T+ O, [& t7 W. T3 |
- {
+ _" s- K L( g4 h$ \ - Res =USART_ReceiveData(USART1);//(USART1->DR); //读取接收到的数据
6 k" y" _7 a# k" e* y - if(USART_RX_CNT<USART_REC_LEN)
; A) D: I8 ^$ V+ u# j - {
' q( K4 Q0 B3 \7 N7 n g" t - USART_RX_BUF[USART_RX_CNT]=Res; F' Q6 j: n" U9 n# c5 s
- USART_RX_CNT++; 2 t7 \$ e* ^2 ?8 A0 F5 D9 X
- }
& { |! ^+ B3 M - }
; |" c7 t& o$ P - #if SYSTEM_SUPPORT_OS //如果SYSTEM_SUPPORT_OS为真,则需要支持OS.# o: C. Y, J4 v9 S6 Z
- OSIntExit(); % ]2 h7 G5 D2 s
- #endif
+ s& u+ H1 Y! X$ H4 O n - } , o* C& Y' p) O! Y+ V2 b
- #endif
复制代码
. p1 a2 B# F$ s1 P; o$ L——uart.h 文件:' V4 i' O5 _7 f7 U( h# e
* V& O/ N1 q1 Q0 H4 k- #define USART_REC_LEN 41*1024 //定义最大接收字节数 41K, X* V( U z$ n# T9 `. ^6 a
- #define EN_USART1_RX 1 //使能(1)/禁止(0)串口1接收
; b( [: ~ E, x -
: I& s1 J' n8 g9 h" x0 t& G - extern u8 USART_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符 ' T# h ?& O" m z. P+ i1 J/ a$ A/ b
- extern u16 USART_RX_STA; //接收状态标记
+ F+ Y, f- b7 e3 z2 C; x6 q - extern u16 USART_RX_CNT; //接收的字节数
3 M+ ]" k8 ~6 h& d' K - //如果想串口中断接收,请不要注释以下宏定义) i3 O. n5 k5 C" f' s: ^
- , X, b. T1 [# E/ F. D9 R
- void uart_init(u32 bound);
2 S$ Y. x4 X2 n - #endif
复制代码
$ @5 M' a4 q8 b4 l/ J% }- H——main.c 文件:
0 b% r! \; k- c% i
& W8 A( a. c5 Q4 K7 R/ `* j- int main(void)
5 d6 t0 X: {7 t: m0 ` - { ) c ^- Z) w# m! R1 w8 _; [
- u8 t;' o6 `$ N6 q2 v- D& c7 R
- u8 len;
' [: ?. g+ w; W2 J6 `" _% ]! x2 R - u16 times=0; , } S* |8 `1 \5 v& S* X/ d
- 0 q, L" M, r, t& w8 e5 S
- delay_init(); //延时函数初始化
# H4 k _* Q& g( k( R; ^% x8 ]& _4 e. l - NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);// 设置中断优先级分组2
! J8 P5 G: W: l% q - uart_init(115200); //串口初始化为115200, {$ v$ _( \8 T2 p0 A+ O8 E5 k; B
- 7 p' Z4 A. J. s1 w: S5 b
- while(1)
2 { ?/ W- Y$ s- J" I) [' x - {- a( D' X0 }2 o5 M U* w @# k
- if(USART_RX_STA&0x8000)
3 J* U6 L# s$ g; X* l5 | m4 k - {
5 c9 j1 N8 m4 e* m - len=USART_RX_STA&0x3fff;//得到此次接收到的数据长度
' K# T: o8 w9 o2 H0 u. w K - printf("\r\n您发送的消息为:\r\n");
6 p Q; b8 U4 W8 G* S2 P* u8 \7 X - for(t=0;t<len;t++) g: v" a9 S3 I" y) r1 l D
- {$ e' s7 G* x& P# D+ F. r6 |
- USART1->DR=USART_RX_BUF[t];) a% s4 B+ l8 l- p1 u
- while((USART1->SR&0X40)==0);//等待发送结束8 b0 V& ]6 p, h! R
- }
/ e' t# n( n! l3 X - printf("\r\n\r\n");//插入换行! E2 C u8 ^3 L+ f$ ~& P
- USART_RX_STA=0;+ ?4 D% R1 J9 M1 V! C& p) S
- }else
( _0 o: R( S+ i3 F8 J' R - {
( ]1 j7 u% y/ ~6 u - times++;
( x- a J7 Q. v. E3 b! C - if(times%5000==0)2 `9 T. z- P8 }) w
- {* T% o& h6 z/ Q* ~
- printf("\r\n串口发送与接收\r\n");
4 g- @( i3 {. D - printf("\r\n123456\r\n\r\n");
. E0 d3 ^4 S2 A4 x* K8 I2 |8 f - }
: y2 e9 C1 U. l - 2 @: M7 J0 P: R) f) z6 }4 \
- delay_ms(10);
]: L# B7 l# _' n# G3 b2 g - }
' a: H4 l' [3 _) L+ |6 X5 L - } " G# D- r' E. L, e4 ]
- }$ x8 ?7 r/ n& N5 r
复制代码 $ l$ ?# \# h) a8 \6 p, Y$ O
# G& o# b' I. c8 h" X/ i
a% K& ^9 t2 ]2 g! U/ i
8 S5 n: z3 i' e- o: n
8 M/ l3 \ t0 B* ^1 ^) l
|