【经验分享】STM32H7的USART应用之RS485

[复制链接]

STMCU小助手发布时间：2021-10-27 11:12

文章
文章封面:
文章简介:	STM32H7支持RS485的硬件流控制，即有一个专门的引脚来控制485 PHY的收发状态切换。V7开发板用的USART3，需要用PD12来控制，而这个引脚要用于FMC，所以用的是一个通用IO。

31.1 初学者重要提示
  学习本章节前，务必优先学习第30章，RS485用到的串口FIFO也是建立在30章的基础上。
  了解了本章31.2和31.3小节的基础知识后，强烈推荐看此贴的两个文档，对RS485讲解的比较透彻
  STM32H7支持RS485的硬件流控制，即有一个专门的引脚来控制485 PHY的收发状态切换。V7开发板用的USART3，需要用PD12来控制，而这个引脚要用于FMC，所以用的是一个通用IO。
  经常会有网友咨询为什么程序里面收发切换没有做延迟处理，这里就涉及到一个关键的知识点TXE发送空中断和TC发送完成中断的区别，详细看教程中说明即可。
31.2 RS485的基础知识
  背景知识（了解即可）
智能仪表是随着80年代初单片机技术的成熟而发展起来的，现在世界仪表市场基本被智能仪表所垄断。究其原因就是企业信息化的需要，企业在仪表选型时其中的一个必要条件就是要具有联网通讯接口。最初是数据模拟信号输出简单过程量，后来仪表接口是RS232接口，这种接口可以实现点对点的通信方式，但这种方式不能实现联网功能。随后出现的RS485解决了这个问题。

EIA-485（过去叫做RS-485或者RS485）是隶属于OSI模型物理层的电气特性规定为2线、半双工、平衡传输线多点通信的标准，是由电信行业协会（TIA）及电子工业联盟（EIA）联合发布的标准。实现此标准的数字通信网可以在有电子噪声的环境下进行长距离有效率的通信。在线性多点总线的配置下，可以在一个网络上有多个接收器。因此适用在工业环境中。

EIA一开始将RS（Recommended Standard）做为标准的前缀，不过后来为了便于识别标准的来源，已将RS改为EIA/TIA。电子工业联盟（EIA）已结束运作，此标准目前是电信行业协会（TIA）维护，名称为TIA-485，但工程师仍继续用RS-485来称呼此协议。

  RS485电气特性
RS-485的数据最高传输速率为10Mbsp。

RS-485接口是采用平衡驱动器和差分接收器的组合，抗共模干扰能力增强，即抗干扰噪声性好。

RS-485最大的通信距离约为1219m，最高传输速率为10Mbsp，传输速率与传输距离成反比，在100Kb/S的传输速率下，才可以达到最大的通信距离，如果需传输更长的距离，需要加485中继器。RS-485总线一般最大支持32个节点，如果使用特制的485芯片，可以达到128个或者256个节点，最大的可以支持到400个节点。

关于RS485的逻辑状态，不同厂家的芯片的定义可能不同，但不影响正常的数据收发，这里以TI的为例做个说明，TI的定义方式如下：

A表示非反向输出non-inverting output，B表示反向输出inverting output。

当VA > VB 的时候表示逻辑状态0，被称为ON。

当VA < VB 的时候表示逻辑状态1，被称为OFF。

aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM3OTEwNy8yMDE5MDcvMTM3OTEwNy0yMDE5.png

对应到实际芯片框图上就是下面这样（DE发送使能，D是发送数据端，RE是接收使能，R是接收数据端）：

当用户在D（Driver）引脚输入逻辑高电平时，将在485总线上实现逻辑状态0，即ON状态。接收端R（Receiver）将收到逻辑高电平。

当用户在D（Driver）引脚输入逻辑低电平时，将在485总线上实现逻辑状态1，即OFF状态。接收端R（Receiver）将收到逻辑低电平。

发送状态下，大于|±1.5V |可以有效表示逻辑状态1和逻辑状态0：

接收状态下，大于|±200mv|可以有效表示逻辑状态1和逻辑状态0：

31.3 RS485硬件设计
STM32H743XIH6最多可以支持8个独立的串口。其中串口4和串口5和SDIO的GPIO是共用的，也就是说，如果要用到SD卡，那么串口4和串口5将不能使用。串口7和SPI3共用，串口8和RGB硬件接口共用。串口功能可以分配到不同的GPIO。我们常用的管脚分配如下：

串口USART1  TX = PA9， RX = PA10

串口USART2  TX = PA2， RX = PA3

串口USART3  TX = PB10，  RX = PB11

串口UART4 TX = PC10，  RX = PC11 （和SDIO共用）

串口UART5 TX = PC12，  RX = PD2  （和SDIO共用）

串口USART6  TX = PG14，  RX = PC7

串口UART7 TX = PB4， RX = PB3  （和SPI1/3共用）

串口UART8 TX = PJ8， RX =PJ9 （和RGB硬件接口共用）

STM32-V7开发板使用了4个串口设备。

  串口1用于RS232接口，很多例子的pritnf结果就是输出到串口1
  串口2用于GPS
  串口3用于RS485接口
  串口6 用于TTL串口插座，板子上有GPRS插座和串口WIFI插座。
下面是相关的原理图：

串口3，RS485

关于485的PHY芯片SP3485E要注意以下几个问题：

  SP3485E允许在同一总线上连接32个收发器。
  PB2（RS485_TX_EN）引脚控制收发状态，高电平表示使能发送，低电平表示用于接收。
  由于 485的RO是输出引脚，如果软件上将PB2配置为输出就会冲突（PB2输出高，RO输出低就会短路）。加电阻的话，PB2就可以做其他用途。主要是开发板才这样弄，正式产品不加。
  电阻R15和R165的作用是避免CPU复位期间，TX为高阻时影响总线数据。
  电阻R4和R2是保证空闲时处于确定的逻辑状态，提供可靠性。
  电阻R3是终端电阻。使用终端电阻是为了阻抗匹配，防止不匹配引起的噪声干扰。一般在300米以下，19200bps不需要接终端电阻。终端电阻要接在传输总线的两端。

31.4 RS485驱动设计
RS485的驱动实现是建立在第31章讲解的串口FIFO基础上，关键的知识点已经在第31章节做了详细讲解，这里把485驱动涉及到的两个关键地方做个说明。

31.4.1 RS485驱动初始化
RS485驱动的初始化要对收发控制引脚进行配置，这点要注意，对应的代码如下：

/*- S, K4 W) @; i" |& T& [
*********************************************************************************************************( e2 S! s' _/ {3 F- s. O
* 函数名: bsp_InitUart. [4 o& E h) g6 `
* 功能说明: 初始化串口硬件，并对全局变量赋初值.0 b1 D. G, P F; k
* 形参: 无
$ E; Q* p- [# g$ V( C
* 返回值: 无
# j5 a$ z5 |+ o3 w
*********************************************************************************************************1 v; l) G& b" S% K
*/
: V9 k7 ~9 w( e4 Q; z9 t
void bsp_InitUart(void)% D: d$ |; x) Q5 M) b# M5 T
{
, A8 @% \- X8 U8 |+ C
6 m W! s: D2 @" M1 s& }
UartVarInit(); /* 必须先初始化全局变量,再配置硬件 */& p, E, @! X4 T. E
9 k! {- [5 k0 w3 o% a& P/ m
InitHardUart(); /* 配置串口的硬件参数(波特率等) */' N( g2 b7 R2 j1 R9 r
1 ~6 _ N) Y/ G6 s
RS485_InitTXE(); /* 配置RS485芯片的发送使能硬件，配置为推挽输出 */+ T: }! C" o. w4 M) [& n4 J3 b' z3 W
}8 [+ G: Z; B0 D4 R7 |- t0 K
/*
) \- v) R' s5 y2 c9 F
*********************************************************************************************************
' z" B% F# g9 l# w
* 函数名: RS485_InitTXE
B2 f, }( U7 ]; B8 O6 \7 @
* 功能说明: 配置RS485发送使能口线 TXE
$ f& d+ ?* [3 [, y& \8 C
* 形参: 无
( L1 X3 ]% n8 I3 ] y
* 返回值: 无
' J4 r( w9 ~: E4 t( R0 W/ a. ?
*********************************************************************************************************& B& K( V( A0 q6 D, y
*/3 o- A, e5 L3 I3 M+ m) m
void RS485_InitTXE(void)
0 _3 R) ~' X7 J1 o
{/ H9 g2 J9 G& w7 W# l+ [
GPIO_InitTypeDef gpio_init;6 d& a/ a! R- j3 N" u# m$ n7 g2 M
: K1 |- P, U2 V( a
/* 打开GPIO时钟 */6 u$ G b4 J& O5 x0 w1 I4 D* D- m
RS485_TXEN_GPIO_CLK_ENABLE();/ [0 ^$ z* ]# x$ n, `) l6 o
+ `, e$ L7 j; [) y
/* 配置引脚为推挽输出 */- ?- f$ C1 f9 ~1 X
gpio_init.Mode = GPIO_MODE_OUTPUT_PP; /* 推挽输出 */
+ w2 U! m. B! n( K' {" ]
gpio_init.Pull = GPIO_NOPULL; /* 上下拉电阻不使能 */0 b5 t) V! |8 Z$ H$ ]
gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH; /* GPIO速度等级 */( ~8 c9 c3 y; x$ L+ c# A" Z+ O3 @' ]
gpio_init.Pin = RS485_TXEN_PIN;0 h7 Y. y4 p5 ]4 l& m
HAL_GPIO_Init(RS485_TXEN_GPIO_PORT, &gpio_init);
% |% r/ U4 O0 \* |8 W3 q+ X
}

复制代码

31.4.2 RS485驱动回调函数初始化
由于RS485是半双工，收发要做切换，初始化的时候专门配套了回调函数：

/*
' ^* X. \; e h- Z
*********************************************************************************************************
: I' `7 i* B+ `2 d
* 函数名: UartVarInit
( @3 Z! N6 b+ ?8 S$ c* k* k
* 功能说明: 初始化串口相关的变量
. O U% {8 v6 C, z7 y/ @: [
* 形参: 无
& C6 i3 f# z( z2 N3 l
* 返回值: 无; I/ h1 _0 `$ o9 t0 `
*********************************************************************************************************
3 I3 y" @8 T7 K9 r0 S& ]. ?
*/
, @+ L6 n" T+ m: a
static void UartVarInit(void), J' J: ?* D0 d
{
: g |: l% B, x* n- G9 L4 c3 @
8 ?! B- |# F u( ^4 {
#if UART3_FIFO_EN == 1/ E) x8 ?1 H9 E( g! Y5 d
g_tUart3.uart = USART3; /* STM32 串口设备 */% m: l8 l9 s/ @$ J
g_tUart3.pTxBuf = g_TxBuf3; /* 发送缓冲区指针 */
. M2 R! ~ B q7 c+ z
g_tUart3.pRxBuf = g_RxBuf3; /* 接收缓冲区指针 */
$ f U" i, ^) w, k- U1 s
g_tUart3.usTxBufSize = UART3_TX_BUF_SIZE; /* 发送缓冲区大小 */( z3 C1 m. ]4 e; U
g_tUart3.usRxBufSize = UART3_RX_BUF_SIZE; /* 接收缓冲区大小 */
& ^* o$ D! x" c0 c6 I9 D
g_tUart3.usTxWrite = 0; /* 发送FIFO写索引 */
% B8 R' v# P3 s
g_tUart3.usTxRead = 0; /* 发送FIFO读索引 */
: ~2 S" ]: V+ S' v2 _
g_tUart3.usRxWrite = 0; /* 接收FIFO写索引 */
7 C8 f5 g4 i: `) d7 a3 v
g_tUart3.usRxRead = 0; /* 接收FIFO读索引 */# [; x9 |5 p1 z, {* n# K8 P
g_tUart3.usRxCount = 0; /* 接收到的新数据个数 */
9 L6 z' t7 G1 z" Q4 r2 u
g_tUart3.usTxCount = 0; /* 待发送的数据个数 */- V5 y1 z9 ?8 L( X# Z
g_tUart3.SendBefor = RS485_SendBefor; /* 发送数据前的回调函数 */
3 C M$ [. B# ~ q! t
g_tUart3.SendOver = RS485_SendOver; /* 发送完毕后的回调函数 */& F0 v* h" y0 K
g_tUart3.ReciveNew = RS485_ReciveNew; /* 接收到新数据后的回调函数 */" U |1 A( | S) K3 w( f
g_tUart3.Sending = 0; /* 正在发送中标志 */$ Q3 \2 d3 ], W S
#endif
Y" [5 F# o& Y- _( u
! A: B2 [) x C
}

复制代码

上面代码中置红的部分是专用于485总线的，对应的代码如下：

/*
8 s$ G r( ^9 @% `
*********************************************************************************************************- Y# Q" d* S; J3 F! `7 L
* 函数名: RS485_SendBefor" c( |/ A" C# F5 V p* |
* 功能说明: 发送数据前的准备工作。对于RS485通信，请设置RS485芯片为发送状态，
8 ~7 v' C& \3 x/ F
* 并修改 UartVarInit()中的函数指针等于本函数名，比如 g_tUart2.SendBefor = RS485_SendBefor
$ d: @" f! w- K0 Y) y
* 形参: 无1 b$ [ ^. p' q. E
* 返回值: 无1 D1 z5 r: \, ^0 r, Y6 `! ]! U, F8 v
*********************************************************************************************************
) {- [! t- K/ A. c7 g
*/# J) u6 s; Z& t1 s' C
void RS485_SendBefor(void)
" C9 d8 K f0 ^, }2 Z* @3 Y
{, I* j2 R& z3 _2 L ^' O
RS485_TX_EN(); /* 切换RS485收发芯片为发送模式 */; H/ u, [& S5 ?: ~4 \' G
}# C% C5 p4 d2 J
( G+ x5 t' f5 ?3 J( Y/ r% e
/*
( l P+ F& @7 A+ S; ?* b& B
*********************************************************************************************************) R$ b* I( B' F. a: E2 _% Y( c
* 函数名: RS485_SendOver- j4 b/ ~5 S) G3 A% ~. v. L7 k
* 功能说明: 发送一串数据结束后的善后处理。对于RS485通信，请设置RS485芯片为接收状态，
+ `% y1 q+ B' }# Q
* 并修改 UartVarInit()中的函数指针等于本函数名，比如 g_tUart2.SendOver = RS485_SendOver
. A$ J/ g" ~" `3 j7 W; v* O3 u
* 形参: 无
# n: V- \$ v$ Z
* 返回值: 无
+ _4 l, J% W6 t1 L6 t+ s: _
*********************************************************************************************************; I [/ S$ C( @+ [0 q5 f
*/
+ K; R! K( \: f1 t
void RS485_SendOver(void)
% j) t2 y/ U9 j1 r' r, J v3 s* M- \
{8 X& c- D) B) |0 f0 O
RS485_RX_EN(); /* 切换RS485收发芯片为接收模式 */1 {; ~" N6 q7 x$ \: O" R6 {" d6 z
}% y: B( U" @2 Y" y5 Y
. I, G1 C5 g& {. d- a5 ~
/*
' w) ]/ T) c# H$ r: u8 g+ f- s
*********************************************************************************************************" a; R$ _) M" N% J% [
* 函数名: RS485_ReciveNew
* _9 R0 t1 a) I5 Q! R! @5 |& k! W
* 功能说明: 接收到新的数据
0 ? i6 o+ R' p7 ~5 E, d% u
* 形参: _byte 接收到的新数据: g# k1 C3 v* Z7 Q& N9 ~
* 返回值: 无& V/ U+ o# Q" _3 _* i; E/ j
*********************************************************************************************************
! {- G ~. R/ }, ~1 Z
*/, m C4 a+ A% ?1 f3 U
//extern void MODH_ReciveNew(uint8_t _byte);
9 O; \& ^; e u8 i3 a) l3 x
void RS485_ReciveNew(uint8_t _byte)! n f; e0 b& |( D4 a7 t+ b. w1 F
{
# ~5 z# x: g% M/ h3 o; i
// MODH_ReciveNew(_byte);
* C1 t6 p, p a3 o) _4 L
}

复制代码

  函数RS485_SendBefor
发送数据前的准备工作。对于RS485通信，请设置RS485芯片为发送状态。

  函数RS485_SendOver
发送一串数据结束后的善后处理。对于RS485通信，请设置RS485芯片为接收状态。

  函数RS485_ReciveNew
接收到新的数据，用于Modbus通信协议。这里未用到Modbus，所以将对应的内容注释掉了。

31.4.3 RS485发送处理
串口数据的发送主要涉及到下面四个函数，调用关系是如下：

RS485_SendStr –> RS485_SendBuf –> comSendBuf -> UartSend

实际应用中，大家调用函数RS485_SendStr，RS485_SendBuf或者comSendBuf均可。另外特别注意代码中置红的部分，用于设置485发送使能。

/*+ m/ Q9 b) ^ q0 W
********************************************************************************************************* O ^' i0 c. F! L, ~' s
* 函数名: RS485_SendBuf
5 Y6 }3 Z4 z. R9 q/ l( H9 c
* 功能说明: 通过RS485芯片发送一串数据。注意，本函数不等待发送完毕。- R1 o7 Z! I' x# E' d- R; Q2 `
* 形参: _ucaBuf : 数据缓冲区
* |' X- F. K, e
* _usLen : 数据长度
* l/ R" B+ c2 h0 ^) P. w4 ?% y0 Z
* 返回值: 无
* v0 f* {3 R5 e* E! |! o
*********************************************************************************************************) H3 q: S" k/ t# S# L
*/
8 ?# D! A5 w2 ~9 s
void RS485_SendBuf(uint8_t *_ucaBuf, uint16_t _usLen); B2 u; V7 f: o7 p2 g5 i4 m- j3 x
{) ~8 y1 v0 n8 q8 H. S
comSendBuf(COM3, _ucaBuf, _usLen);: G/ [6 W1 k( y$ E) M" P3 n
}5 S) K9 E6 @6 A, [; ?
6 x" g$ _4 W# ~- }
/*
; R$ w0 ]( @! s# N. n" [; p1 h) {
*********************************************************************************************************
. d: N! i7 B& ]$ E5 \% @
* 函数名: RS485_SendStr
4 h9 y7 {. G' s
* 功能说明: 向485总线发送一个字符串，0结束。
1 ~0 ^+ e$ }) x7 b5 E
* 形参: _pBuf 字符串，0结束2 D$ f% @6 w& \' x. w, \2 D
* 返回值: 无
3 }7 K; Y3 k# T/ m; P& `( W3 u6 n
*********************************************************************************************************
$ [3 _' B) Q0 ` `6 ]. N
*/% j4 C }8 h4 E
void RS485_SendStr(char *_pBuf)
: Y( i) T- |- t1 `2 T
{
8 O w0 e+ R* r/ B) j+ T( c) c1 j
RS485_SendBuf((uint8_t *)_pBuf, strlen(_pBuf));
" M" A. Q: \! [- u$ b# K* m* \
}
+ i5 U9 D" i1 w: ?4 Y7 a8 K/ j
! w) s3 ^3 C4 b* x' y# [
/*3 F* I. q9 a* _
*********************************************************************************************************
0 ^. S/ c, W' Q# o0 e8 j% A
* 函数名: comSendBuf) U# g7 C; y) x0 V J3 I" Z
* 功能说明: 向串口发送一组数据。数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送
S5 i- F% W0 r% P, j. H, @
* 形参: _ucPort: 端口号(COM1 - COM8)
& K3 C) L! m# `6 z: I
* _ucaBuf: 待发送的数据缓冲区0 a& n& f+ _( ]; k) i$ j
* _usLen : 数据长度
0 L- P1 e& P5 W# j
* 返回值: 无
6 Q& o: L- `+ A, Z% ]5 y! J
*********************************************************************************************************, F$ n& v9 O) N8 w9 r
*/, f! S8 N: T3 T9 V& G
void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen)+ {9 W4 n& T* q, V- V0 N
{* W" t: s7 M7 V( M8 c( b
UART_T *pUart;
: [: t, w$ N8 I% _2 b. z* |
1 [- U# U6 L& n1 ?5 e7 s2 c3 ~* [
pUart = ComToUart(_ucPort);
2 J* { Y3 ?6 Q t; d
if (pUart == 0)
5 o( | a% D2 Y6 s$ O, r; }& u
{- j% A) [& [* q9 @
return;( H l6 ]+ V; `4 V& J8 N( E$ _( h
}' X; |& E# f/ y/ {- ~4 C( e; {
1 e/ c( I" z( e
if (pUart->SendBefor != 0)
2 {: C! g9 h& e! O
{
& k- X0 I' F' C A) S' ?8 _
pUart->SendBefor(); /* 如果是RS485通信，可以在这个函数中将RS485设置为发送模式 */
6 [5 l! P( i4 Y( @. p
}
1 q: u4 N4 ?9 v4 J6 ^2 Y
& D5 I% B/ K. Y
UartSend(pUart, _ucaBuf, _usLen);2 `2 W7 s3 U8 F" c) x! U: V
}; S1 P9 g1 Q v; O4 ?9 U$ x5 e8 f
1 t# [ c3 A# P0 |) Y
/*
+ x3 l: |9 A7 i$ B5 y/ |; q
*********************************************************************************************************( i. c1 K j8 v8 }% x
* 函数名: UartSend
! c; B0 ~2 ]( j, H# ?1 k
* 功能说明: 填写数据到UART发送缓冲区,并启动发送中断。中断处理函数发送完毕后，自动关闭发送中断9 h b2 a. c, J4 s8 g
* 形参: 无
0 |* N; r g O
* 返回值: 无% M+ D2 p) W8 W
*********************************************************************************************************
, Z6 g6 Q& n! V3 H8 z5 c
*/" |5 o! S" ~- ~0 C% E1 s- ~
static void UartSend(UART_T *_pUart, uint8_t *_ucaBuf, uint16_t _usLen)3 K( }% P5 `% F
{
4 a9 W* G: v! ]0 o. d0 g( K
uint16_t i;
9 q f- B6 X+ l3 w
, p0 }; @, W/ v! l3 p. m) I' z
for (i = 0; i < _usLen; i++)8 y5 u' K$ U" E& X0 u/ F! I. g
{
; q/ d8 Z& g- M
/* 如果发送缓冲区已经满了，则等待缓冲区空 */
' [! \- K1 H. F6 x% G5 }, H6 M
while (1); R2 k8 {( J. i( w
{
& w+ p' H+ U: j6 i, L# F
__IO uint16_t usCount;( t9 D/ L. w3 {3 `* B
' ?# c. R3 `. m6 Q/ Z* k7 P
DISABLE_INT();
) B! B u0 M. p# n! E- }3 n
usCount = _pUart->usTxCount;
9 ?! s- o% z* W1 t) w- F3 t0 E
ENABLE_INT();
9 ^5 C8 x7 z0 n3 }! Z& \. p
: m3 Z1 ~% a" X4 C& Y4 l4 K
if (usCount < _pUart->usTxBufSize)
2 O3 T6 L. ^" U& ^
{/ f: t* {1 _% R* H" w
break;" J) C/ w: e6 Q- A9 Y. J( ^/ k
}+ ~4 ~6 K% W9 l/ c7 u+ G7 w8 u
else if(usCount == _pUart->usTxBufSize)/* 数据已填满缓冲区 */# R: e/ h4 J6 D+ `$ e( j
{
/ m$ s$ _ W& d
if((_pUart->uart->CR1 & USART_CR1_TXEIE) == 0)
2 q/ H9 w" ^8 g- F) d( ^' V# P/ @
{; O+ s) a3 W# O! B( K. z
SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
: m8 ]' @7 N7 J: i1 A' @6 @! E) l
}
1 j3 Z, [# I. [) O7 B8 N
}
0 X: y" A6 m4 I7 s/ O8 F% N
}
# U9 K0 }& o! _
+ o, ?& Q: {+ }/ Z5 {) z" ~
/* 将新数据填入发送缓冲区 */
: B6 A3 r# Q1 m8 @; i' c& f' Y
_pUart->pTxBuf[_pUart->usTxWrite] = _ucaBuf<i>;. B1 t; s3 c! J. g4 c5 D
8 k7 y# _; U' a0 c" ~ N1 I
DISABLE_INT();
W& w7 _* h# O# _2 R2 k
if (++_pUart->usTxWrite >= _pUart->usTxBufSize)7 _* C6 U/ _6 t/ S' `" u+ ]) g+ H* s2 r
{
6 P4 c, D5 j+ p* v7 e- J
_pUart->usTxWrite = 0;
8 @6 q9 P; S9 \& `) r4 N
}# J: h: A/ d$ W* \5 j! B y3 r9 ~* K
_pUart->usTxCount++;
; ]/ P( i+ W3 u" B/ f
ENABLE_INT();
. |" D/ f7 ?, R8 x
}# V( y' b6 x) E
* A/ w S5 e# s$ c, @. ?
SET_BIT(_pUart->uart->CR1, USART_CR1_TXEIE); /* 使能发送中断（缓冲区空） */' |: d3 {0 a3 I2 \* \$ g
}</i>

复制代码

函数UartSend的作用就是把要发送的数据填到发送缓冲区里面，并使能发送空中断。

如果要发送的数据没有超过发送缓冲区大小，实现起来还比较容易，直接把数据填到FIFO里面，并使能发送空中断即可。
如果超过了FIFO大小，就需要等待有空间可用，针对这种情况有个重要的知识点，就是当缓冲刚刚填满的时候要判断发送空中断是否开启了，如果填满了还没有开启，就会卡死在while循环中，所以多了一个刚填满时的判断，填满了还没有开启发送空中断，要开启下。

注意：由于函数UartSend做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。函数RS485_SendStr，RS485_SendBuf或者comSendBuf是供用户调用的。

31.4.4 RS485数据接收
下面我们再来看看接收的函数：

/*: j9 }# |; E9 S4 L. g; U$ P9 a
*********************************************************************************************************
) E/ J! y& Z, a1 }
* 函数名: comGetChar
, Y8 r, c; ]- X! Q( r* i b
* 功能说明: 从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。
5 o' G3 j" P* S J
* 形参: _ucPort: 端口号(COM1 - COM8)
]. Y( o$ ?: [1 W5 A L% S+ \
* _pByte: 接收到的数据存放在这个地址
; G! I# o( ~" B8 ]- R7 U
* 返回值: 0 表示无数据, 1 表示读取到有效字节8 g) W6 F1 j+ k3 g- `6 T D
*********************************************************************************************************/ G0 o+ J1 ~$ q& a' {0 b
*/
1 K9 U- V( D E) Z0 t6 A& ~
uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)
' B8 |. J. M- P" ?( V
{, g( z- |, h' U$ E3 W
UART_T *pUart;
0 S$ @' z' `- S3 W7 f. u+ u
! p* \/ o: Q Q! L% H- G, F4 |
pUart = ComToUart(_ucPort);
J/ u' E2 v' u- c! ~
if (pUart == 0) t4 I7 S* M5 `$ h+ l7 \
{7 y- g5 p8 }9 o! s$ t8 W
return 0;, T0 E* H4 j. j2 K
}
^: W& @1 M0 }0 J @
: f# t9 b& K) \7 Q7 d# c/ k; }
return UartGetChar(pUart, _pByte);' V: q! q0 U! i7 H& z* N" \# I
}
6 Z0 V8 X6 Z5 |1 U, j0 N# g; i& u* _/ T
& d% m& c+ W- ~
/*3 K1 f6 h9 o/ z: Y `
*********************************************************************************************************& S) ?* L% f& {
* 函数名: UartGetChar" p. B/ v* e3 }# W2 F3 `+ W0 w
* 功能说明: 从串口接收缓冲区读取1字节数据（用于主程序调用）1 S( r0 |; }3 q% ] D
* 形参: _pUart : 串口设备
# w5 ?% s5 W/ F' @; L2 [
* _pByte : 存放读取数据的指针$ j0 ~8 I6 r3 H8 T
* 返回值: 0 表示无数据 1表示读取到数据: Q# r' M, V8 p" t7 W! U9 T1 d
*********************************************************************************************************
0 t5 E, t3 Z. E) Z
*/
5 r% g" j- l! s$ `. y# `9 W2 ]
static uint8_t UartGetChar(UART_T *_pUart, uint8_t *_pByte)
0 _# f! Y5 F" D3 G( z: J ?
{
$ S6 o2 o( v& n4 Y$ s8 f
uint16_t usCount;+ W0 d4 k; P5 i0 B7 ~
1 J- A/ u3 Z! d2 O$ P( W
/* usRxWrite 变量在中断函数中被改写，主程序读取该变量时，必须进行临界区保护 */
% X8 ]9 k9 q% q8 u" U1 \5 I/ k
DISABLE_INT();
5 T; i4 o. M2 i+ ~& Z
usCount = _pUart->usRxCount;
7 |8 u% m. o0 q4 ?. e5 e
ENABLE_INT();
0 x1 w* ~7 x. ?5 I P. Y
+ I( `1 _: s8 b: u9 ]
/* 如果读和写索引相同，则返回0 */, |) Q: Q1 V; P. z% ]
//if (_pUart->usRxRead == usRxWrite)7 W7 \$ t5 b; C& z9 w6 p
if (usCount == 0) /* 已经没有数据 */
; H% l L$ z' ^# f) m
{
+ n! I* u" V' c' ?0 e( z8 v
return 0;6 P* ?6 f" D; u
}( j$ v! g6 l+ y5 r' Z
else2 R3 x3 Y N! L4 ?0 F4 M
{# y, m P7 ^5 U6 }' O: J
*_pByte = _pUart->pRxBuf[_pUart->usRxRead]; /* 从串口接收FIFO取1个数据 */
; S9 a/ Y/ a: F6 `& }- W
9 c# I% c+ _; ~! C$ M0 x
/* 改写FIFO读索引 */" X/ P" n" G& z4 x) l
DISABLE_INT();5 ]# _0 U1 L( X
if (++_pUart->usRxRead >= _pUart->usRxBufSize)
9 G8 b! t. M7 y& }. d9 C% u" G0 ?
{( ^; M) G! y- g4 X5 i& j% Y$ e) x* T
_pUart->usRxRead = 0;
: t& u" i6 G# H' N
}, v# E! X$ ~8 j! e u1 H& v% U
_pUart->usRxCount--;
& G: D2 H* A, H( z: y
ENABLE_INT();
4 e" h4 @( ~; V( s; L, W2 w: H' x
return 1;
# A0 ~6 a+ ~: m' i# n9 {" e
}, ]. w0 R6 u& E" p" P7 B h
}

复制代码

函数comGetChar是专门供用户调用的，用于从接收FIFO中读取1个数据。具体代码的实现也比较好理解，主要是接收FIFO的调整。

注意：由于函数UartGetChar做了static作用域限制，仅可在bsp_uart_fifo.c文件中调用。

31.4.5 RS485驱动中断服务程序的处理
串口中断服务程序是实现RS485驱动的关键部分，主要实现如下三个功能：

  收到新的数据后，会将数据压入RX_FIFO。
  检测到发送缓冲区空后，会从TX_FIFO中取下一个数据并发送。
  对于RS485半双工串口，发送前会设置一个GPIO=1控制RS485收发器进入发送状态，当最后一个字节的最后一个bit传送完毕后，设置这个GPIO=0让RS485收发器进入接收状态。

下面我们分析一下串口中断处理的完整过程。

当产生串口中断后，CPU会查找中断向量表，获得中断服务程序的入口地址。入口函数为USART1_IRQHandler，这个函数在启动文件startup_stm32h743xx.s汇编代码中已经有实现。我们在c代码中需要重写一个同样名字的函数就可以重载它。如果不重载，启动文件中缺省的中断服务程序就是一个死循环，等于 while(1);

我们将串口中断服务程序放在bsp_uart_fifo.c文件，没有放到 stm32h7xx_it.c。当应用不需要串口功能时，直接从工程中删除bsp_uart_fifo.c接口，不必再去整理stm32h7xx_it.c这个文件。下面展示的代码是8个串口的中断服务程序，RS485用的USART3。

#if UART1_FIFO_EN == 1
1 D" _. k8 h/ W5 i+ g
void USART1_IRQHandler(void), D3 _; D( ^. d7 e4 P6 G* n# ?
{( b4 j0 `( M3 W. y
UartIRQ(&g_tUart1);
0 I, S7 `- ^1 Q6 Q5 v/ T
}/ w$ H$ ^, _+ k
#endif
: P+ d* U. I) Y# J! g, ~
! I1 a# {4 ]( W3 X8 P6 F" n' Z* ?7 W
#if UART2_FIFO_EN == 1
# @, ?% o( M- p
void USART2_IRQHandler(void)# T+ z" z! R7 m* c7 ]
{- i8 ]& s& f+ k& h1 p& E
UartIRQ(&g_tUart2);
& `+ L" A2 s# s1 u O5 F) P6 k
}" ?7 o1 q/ G; \, S/ m- u! u
#endif
7 _( R2 h2 j8 _1 ^! S0 r( z
# E) r# L# [8 {- g1 v
#if UART3_FIFO_EN == 1
void USART3_IRQHandler(void)
; y+ r$ q1 W/ C; b. \
{( O+ f9 N6 J' z7 d( F
UartIRQ(&g_tUart3);
; N; H, k0 S& e7 r, a: g& h1 X
}# i7 q$ U3 v ?2 G# C: a7 S! l1 X
#endif
0 G/ k- Q) ]# C5 z0 z8 J8 p$ u9 t+ j
: P* L+ A- Q7 S/ S1 H" h8 q
#if UART4_FIFO_EN == 1
3 R$ r; F& l3 R0 {
void UART4_IRQHandler(void)
7 e0 U0 U, _0 U" U+ g b* _) |: q( ^
{
. ]7 ~1 G6 c% x3 d: R# R9 H
UartIRQ(&g_tUart4);
7 N! h1 X+ l7 R$ R
}' O& O; y- f: m. [% S E; c0 _7 f
#endif) q S" }" \/ E8 x6 ]9 K
# ^0 X8 h- g" j: u
#if UART5_FIFO_EN == 1
4 Y& \% a6 z0 \/ t& ^" w
void UART5_IRQHandler(void)0 U. C* c' _' J
{
! e. M8 t; h) R
UartIRQ(&g_tUart5);$ o# t+ Z3 F& m
}/ V8 g/ p6 y) C+ o
#endif* Y9 Y7 e7 X( v# n3 g; w" S5 D8 U
# m5 q+ @( R& ~5 O7 l# A- x
#if UART6_FIFO_EN == 1( o' @7 A# n* }3 X
void USART6_IRQHandler(void) e) X0 I3 p+ v) J$ i
{; u% m, c( I8 q" R2 C2 b
UartIRQ(&g_tUart6);
5 c7 A- H. P3 Z2 I
}
: \0 n9 T9 p7 g* Q
#endif# T0 p/ ^" d4 `7 y2 a
+ K3 S5 ]9 H: w1 p" \
#if UART7_FIFO_EN == 19 I0 j' h, l: A8 X
void UART7_IRQHandler(void)( I4 t! \6 T7 G% ?) d# d% B4 p z% L
{3 M3 z( t( n5 K* {5 _! N
UartIRQ(&g_tUart7);( {' n, U# v; d* {
}3 i+ ?- D: V0 `/ L5 T
#endif( D# s+ Q, {1 f
( D r2 V6 n! h3 ]4 a/ `8 p7 S6 ?
#if UART8_FIFO_EN == 1
void UART8_IRQHandler(void)6 S1 m; S2 u2 e6 C8 U+ ~$ \
{4 ~, `, K" C) p3 J! F3 g/ l; K# ^$ w
UartIRQ(&g_tUart8);( p2 I; k# x' S
}
3 W. c, l; q3 c# l3 [- v
#endif

复制代码

大家可以看到，这8个中断服务程序都调用了同一个处理函数UartIRQ。我们只需要调通一个串口FIFO驱动，那么其他的串口驱动也就都通了。

下面，我们来看看UartIRQ函数的实现代码。

/*
) m# E4 q! I. ^+ {1 a- J- a- p( E0 _
*********************************************************************************************************0 o( d# Z$ e9 U* |5 G/ L
* 函数名: UartIRQ6 A/ P. Y! k' S' E7 i# x. b2 f
* 功能说明: 供中断服务程序调用，通用串口中断处理函数
8 `5 J8 E" |8 S; x# X0 P
* 形参: _pUart : 串口设备, _5 q# l" _' P& \( e! W" \# t
* 返回值: 无
7 B* M+ d8 k6 N1 |& D/ q
********************************************************************************************************** w5 b1 _/ a2 V7 h
*/
6 r- n; j( O2 A0 K }$ ~
static void UartIRQ(UART_T *_pUart)" k1 o2 ~1 T, U& h+ N' [3 |' N7 Q/ a% f
{% S) i* V3 b5 D5 e: s4 @ {) b, t% V
uint32_t isrflags = READ_REG(_pUart->uart->ISR);! ?( G7 C: G7 S% X" F7 S. _; ~
uint32_t cr1its = READ_REG(_pUart->uart->CR1);
$ h$ _, t3 }7 b- X0 t! j
uint32_t cr3its = READ_REG(_pUart->uart->CR3);
7 c7 k9 i/ B0 {' p4 x
: y: T" Q) A) N/ ~ R3 m
/* 处理接收中断 */! l! l1 q* A8 M& }5 s: ]5 @$ j" `, }
if ((isrflags & USART_ISR_RXNE) != RESET)
5 r4 I# d& M3 a8 r5 u
{
" U$ i4 m2 j# z, o
/* 从串口接收数据寄存器读取数据存放到接收FIFO */
" v" Y' J9 h3 l
uint8_t ch;- H; w) k. \( t$ d
& C9 E* K ]9 H/ B* M1 D5 f
ch = READ_REG(_pUart->uart->RDR); /* 读串口接收数据寄存器 */2 d9 g. ~" z# g" O. g, c. {% E$ t
_pUart->pRxBuf[_pUart->usRxWrite] = ch; /* 填入串口接收FIFO */
4 |. R% }" P5 l; W- C
if (++_pUart->usRxWrite >= _pUart->usRxBufSize) /* 接收FIFO的写指针+1 */
$ r, e) L3 ?4 i E) Q* U
{' ^8 w" J% K' M& K$ @- N. U- p2 }& V
_pUart->usRxWrite = 0;4 Z+ ?7 S0 I4 F( O5 v9 p4 _3 ^1 E: x- x
}
; x* K- j& I1 t4 Y0 M) A0 R! f! @
if (_pUart->usRxCount < _pUart->usRxBufSize) /* 统计未处理的字节个数 */
. F) }6 T9 Z) t- W& `
{" R3 j; m) Q/ M3 [, R1 V
_pUart->usRxCount++;2 m6 i* x F7 ?7 h, A, p5 c
}1 m0 F) `, E4 O( z) T
7 p5 o& n' A( g
/* 回调函数,通知应用程序收到新数据,一般是发送1个消息或者设置一个标记 */5 `8 _0 ]. K& D- h' i. M# {
//if (_pUart->usRxWrite == _pUart->usRxRead)& G6 B& s; d/ I, W; e' D
//if (_pUart->usRxCount == 1)$ a0 K' k7 u! E) f. P9 {
{
4 T r% C, M8 g! }# \
if (_pUart->ReciveNew)
( r: t6 F1 |1 j. j* C0 d. X; X( D
{
' Z! Q3 S5 B. M& G: d2 z
_pUart->ReciveNew(ch); /* 比如，交给MODBUS解码程序处理字节流 */
: P& z- x! v! ?7 s
}' I) L" u0 p2 o, u7 B1 }7 \) E
}$ k* A$ F: x+ e1 r; j
}6 u8 ?9 V2 T! n0 V4 x
" Z1 ]- D' H9 p$ ?
/* 处理发送缓冲区空中断 */
6 _3 M! M8 N6 f5 y$ W: ?9 X
if ( ((isrflags & USART_ISR_TXE) != RESET) && (cr1its & USART_CR1_TXEIE) != RESET)
, B# J/ P, d' r* e
{+ Y5 Q, j# r/ X
//if (_pUart->usTxRead == _pUart->usTxWrite)
% @' K$ C" J2 q0 |0 o
if (_pUart->usTxCount == 0) /* 发送缓冲区已无数据可取 */
. e% p$ N: J: H# D; W
{, X( A" v, U, [ v
/* 发送缓冲区的数据已取完时，禁止发送缓冲区空中断（注意：此时最后1个数据还未真正发送完毕）*/- t; _0 K' @$ Z8 a4 N p$ u2 H$ o
//USART_ITConfig(_pUart->uart, USART_IT_TXE, DISABLE);# m/ O( P' s" v( K% v- c9 ]+ r
CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TXEIE);
: O! C& R2 h7 V
1 ]! x& \( p& C% Z1 _$ [! {
/* 使能数据发送完毕中断 */' @2 t5 Y7 I& ~! R: H X! s: T
//USART_ITConfig(_pUart->uart, USART_IT_TC, ENABLE);% ~2 {1 [$ O& t
SET_BIT(_pUart->uart->CR1, USART_CR1_TCIE);, p" ?3 |4 m* s- ^) o) c* t
}
5 S* I; c M# ^" R( ^4 i
Else /*　还有数据等待发送 */: L1 s2 W' q5 m; h# G
{9 ?! I/ ?) d$ x) c& h) q% D7 `/ L/ @
_pUart->Sending = 1;8 U- p2 z7 J( r+ g3 ~6 M
; z! U5 |) M" C1 ~: _+ A' j$ {
/* 从发送FIFO取1个字节写入串口发送数据寄存器 */9 j; Q& k# ?- Z( d6 d1 V
//USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);
, A! {7 i. m; ?- h, k8 ^, c
_pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];
: s9 b4 y& [/ ^! `) z0 m1 g
if (++_pUart->usTxRead >= _pUart->usTxBufSize)
# q1 S& k: n7 l5 M: P: c
{
3 ~ ] i2 L2 w+ ~% E9 W/ z
_pUart->usTxRead = 0;
$ r# b( J6 y+ `0 r+ k
}
4 w$ U! ~0 B% M7 u$ Q
_pUart->usTxCount--;
2 X+ R2 `9 K/ L; O0 [6 Q4 ^
}6 I4 n9 `# E' W- \ X' [! l
+ u" h4 d9 v. q( @5 L
}
+ g. A" u) E' t: m
/* 数据bit位全部发送完毕的中断 */
" o9 [- r" x. ]% U3 H0 H' `
if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
5 v2 ?! _2 k- Y) n/ A4 h& b
{. Y$ N- k! z" G8 {5 W
//if (_pUart->usTxRead == _pUart->usTxWrite)
+ p0 U% I1 A7 z! M1 M$ _6 L! M
if (_pUart->usTxCount == 0)) w) B. x% u6 ?9 c; ~! x
{; S- h2 U; Q# C: S# R! x. h
/* 如果发送FIFO的数据全部发送完毕，禁止数据发送完毕中断 */$ w1 Z- l+ V& y& O2 d
//USART_ITConfig(_pUart->uart, USART_IT_TC, DISABLE);/ G. m, P, p3 L! N
CLEAR_BIT(_pUart->uart->CR1, USART_CR1_TCIE);
" d" ^5 H; B* H
& z6 G9 J6 r" d/ T! j# a* J1 L% l1 ~
/* 回调函数, 一般用来处理RS485通信，将RS485芯片设置为接收模式，避免抢占总线 */" c4 ^0 _3 E, z2 m$ c$ Q$ z
if (_pUart->SendOver): B: ^8 L! w, o* `0 L. ]
{4 H, i: k- q: w; k
_pUart->SendOver();
$ P- ~, I5 h; g. ? O# e' n( Q/ E
}
- k5 n% v3 J8 Z, }3 w
0 x/ g6 {. y# e% `
_pUart->Sending = 0;! \$ I5 n. Z$ l5 x8 ~) E; Y9 N0 @
}
, [0 @+ X- \! A7 l+ l, e, V
else6 R; f5 N8 d D1 k
{
( M7 B5 ]. ]5 `9 I. T8 [
/* 正常情况下，不会进入此分支 */
$ c7 R/ S3 E- e2 @8 E2 X
) I+ I! g( I( A
/* 如果发送FIFO的数据还未完毕，则从发送FIFO取1个数据写入发送数据寄存器 */' p- J( o- P. b: q) r$ m2 ^ X
//USART_SendData(_pUart->uart, _pUart->pTxBuf[_pUart->usTxRead]);7 o) ^ U- H" H8 W; t
_pUart->uart->TDR = _pUart->pTxBuf[_pUart->usTxRead];" [/ X: K @( b) g3 H7 F" V
if (++_pUart->usTxRead >= _pUart->usTxBufSize)/ F! S- P; h. Q" P
{% |0 _9 k2 _# ?0 h1 N- `8 A
_pUart->usTxRead = 0;
) i6 b* u7 O. C b: a
}. w# Q) Y3 h: w: |$ m
_pUart->usTxCount--;
5 U* p/ n! \# F- ]1 I+ c C
}. a5 _/ X" L' T" X% E0 _6 E
}$ x% @5 Q; u0 }) H, g/ p6 S9 |
9 O5 t" q- C; R1 e9 O2 _
/* 清除中断标志 */ H) u+ f1 T$ J3 }9 F, V, h
SET_BIT(_pUart->uart->ICR, UART_CLEAR_PEF);7 B: T* M0 g% g& _" y( ]5 K- {
SET_BIT(_pUart->uart->ICR, UART_CLEAR_FEF);; ~) [3 P# @$ P& b* {0 J
SET_BIT(_pUart->uart->ICR, UART_CLEAR_NEF);
& f3 |- v& G7 l' t( G4 ~6 F5 o
SET_BIT(_pUart->uart->ICR, UART_CLEAR_OREF);
S# ?, [% F) r& r1 L
SET_BIT(_pUart->uart->ICR, UART_CLEAR_IDLEF);
" W( M* ~* \2 S3 Y' B
SET_BIT(_pUart->uart->ICR, UART_CLEAR_TCF);* z1 ~# D% G9 `
SET_BIT(_pUart->uart->ICR, UART_CLEAR_LBDF);5 s( ?. K: i$ b3 T# _) i
SET_BIT(_pUart->uart->ICR, UART_CLEAR_CTSF);
3 W2 V2 Y4 L- h1 S
SET_BIT(_pUart->uart->ICR, UART_CLEAR_CMF);
/ P g" O; B; }
SET_BIT(_pUart->uart->ICR, UART_CLEAR_WUF);9 ]+ F, g. F i* x' @" T2 x: s7 s
SET_BIT(_pUart->uart->ICR, UART_CLEAR_TXFECF); ) M! Q2 c7 h$ h! s' ?! |7 e4 H
}

复制代码

中断服务程序的处理主要分为两部分，接收数据的处理和发送数据的处理，详情看程序注释即可，已经比较详细，下面重点把思路说一下：

  接收数据处理
接收数据的处理是判断ISR寄存器的USART_ISR_RXNE标志是否置位，如果置位表示RDR接收寄存器已经存入数据。然后将数据读入到接收FIFO空间。

特别注意里面的ReciveNew处理，这个在Modbus协议里面要用到。

  发送数据处理
发送数据主要是发送空中断TEX和发送完成中断TC的处理，当TXE=1时，只是表示发送数据寄存器为空了，此时可以填充下一个准备发送的数据了。当为TDR发送寄存器赋值后，硬件启动发送，等所有的bit传送完毕后，TC标志设置为1。如果是RS232全双工通信，可以只用TXE标志控制发送过程。如果是RS485半双工通通信，就需要利用TC标志了，因为在最后一个bit传送完毕后，需要设置RS485收发器进入到接收状态。

31.5 RS485板级支持包（bsp_uart_fifo.c）
串口驱动文件bsp_uart_fifo.c主要实现了如下几个API供用户调用：

  bsp_InitUart
  comSendBuf
  comSendChar
  comGetChar
31.5.1 函数bsp_InitUart
函数原型：

void bsp_InitUart(void)

函数描述：

此函数主要用于串口的初始化，使用所有其它API之前，务必优先调用此函数。

使用举例：

串口的初始化函数在bsp.c文件的bsp_Init函数里面调用。

31.5.2 函数comSendBuf
函数原型：

void comSendBuf(COM_PORT_E _ucPort, uint8_t *_ucaBuf, uint16_t _usLen);

函数描述：

此函数用于向串口发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。

函数参数：

  第1个参数_ucPort是端口号，范围COM1 - COM8。
  第2个参数_ucaBuf是待发送的数据缓冲区地址。
  第3个参数_usLen是要发送数据的字节数。
注意事项：

  此函数的解读在第30章30.3.5小节。
  发送的数据最好不要超过bsp_uart_fifo.h文件中定义的发送缓冲区大小，从而实现最优的工作方式。因为超过后需要在发送函数等待有发送空间可用。
使用举例：

调用此函数前，务必优先调用函数bsp_InitUart进行初始化。

const char buf1[] = "接收到串口命令1\r\n";

comSendBuf(COM1, (uint8_t *)buf1, strlen(buf1));

31.5.3 函数RS485_SendBuf
函数原型：

void RS485_SendBuf(uint8_t *_ucaBuf, uint16_t _usLen)

函数描述：

此函数用于向RS485总线发送一组数据，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数comSendBuf实现的。

函数参数：

  第1个参数_ucaBuf是数据缓冲区。
  第2个参数_usLen是数据长度。
注意事项：

调用此函数前，务必优先调用函数bsp_InitUart进行初始化。

31.5.4 函数RS485_SendStr
函数原型：

void RS485_SendStr(char *_pBuf)

函数描述：

此函数用于向RS485总线发送一个字符串，非阻塞方式，数据放到发送缓冲区后立即返回，由中断服务程序在后台完成发送。此函数是通过调用函数RS485_SendBuf实现的。

函数参数：

  第1个参数_pBuf是字符串地址，0结束。
注意事项：

调用此函数前，务必优先调用函数bsp_InitUart进行初始化。

31.5.5 函数comGetChar
函数原型：

uint8_t comGetChar(COM_PORT_E _ucPort, uint8_t *_pByte)

函数描述：

此函数用于从接收缓冲区读取1字节，非阻塞。无论有无数据均立即返回。

函数参数：

  第1个参数_ucPort是端口号，范围COM1 - COM8。
  第2个参数_pByte用于存放接收到的数据。
  返回值，返回0表示无数据, 1 表示读取到有效字节。
注意事项：

  此函数的解读在第30章30.3.6小节。
使用举例：

调用此函数前，务必优先调用函数bsp_InitUart进行初始化。

比如从串口1读取一个字符就是：comGetChar(COM1, &read)

31.6 RS485驱动移植和使用
RS485移植步骤如下：

  第1步：复制bsp_uart_fifo.h和bsp_uart_fifo.c到自己的工程目录，并添加到工程里面。
  第2步：根据485要使用的串口和收发缓冲大小，修改下面的宏定义即可。

#define UART1_FIFO_EN 1
8 W# {% I7 t: ]" B
#define UART2_FIFO_EN 0
6 |: i, c2 j; N c& S- s7 s
#define UART3_FIFO_EN 02 c- C, W' @5 S4 S- b' H
#define UART4_FIFO_EN 0" b1 f- d% [$ F9 I0 d
#define UART5_FIFO_EN 0 B4 u% |6 c$ e9 F7 Z5 X
#define UART6_FIFO_EN 0
9 e7 U. t6 a6 h( V h! N
#define UART7_FIFO_EN 0
3 j( q* c9 _' L/ ~& C
#define UART8_FIFO_EN 0
$ {8 ~% l; g: Q$ ^0 G0 ^
, k' n: q) R& o0 T& }3 t
/* 定义串口波特率和FIFO缓冲区大小，分为发送缓冲区和接收缓冲区, 支持全双工 */) B7 `) F3 n# i' I- N) v( E
#if UART1_FIFO_EN == 1+ c8 [6 `" E/ e& {
#define UART1_BAUD 115200) c3 d7 ?8 Z [' ^$ I+ c- J9 \/ Z
#define UART1_TX_BUF_SIZE 1*1024
% d; I! v G' j& z4 \
#define UART1_RX_BUF_SIZE 1*1024- x8 X) F% @0 t; ~+ f9 d
#endif
/ g/ d( `- I; T m1 U% H: j* {' R) D
1 B/ X7 ?3 v. N. o
#if UART2_FIFO_EN == 13 ^9 r" T0 Q) H" o' z3 [
#define UART2_BAUD 9600
2 x5 Z" v2 }3 K" y/ E
#define UART2_TX_BUF_SIZE 10% m, }0 W3 }( V; F- J: ?, M3 u I$ O
#define UART2_RX_BUF_SIZE 2*1024
7 n) `# s3 X0 J5 `' o- |
#endif
! [2 ~6 j' `6 X3 I3 i
5 c5 Q/ b7 H- \6 @. P4 D
#if UART3_FIFO_EN == 1$ A! K" s1 r" w7 `" U4 t/ o
#define UART3_BAUD 96001 z% r6 E& A5 r
#define UART3_TX_BUF_SIZE 1*10243 k2 Y+ @ n2 _$ @2 Y* ^! S
#define UART3_RX_BUF_SIZE 1*10246 x/ @. m4 k0 D8 _; [$ a
#endif0 r1 C" Q1 T, c3 C0 B
; C7 w) ^2 {: e0 v/ y1 B& g9 e
#if UART4_FIFO_EN == 1
9 R8 w3 V @' h
#define UART4_BAUD 115200# d, n9 d) N% _; t% x* W
#define UART4_TX_BUF_SIZE 1*1024
# r6 O$ k: W8 o# u
#define UART4_RX_BUF_SIZE 1*1024
5 {1 |% J4 x/ k
#endif1 {$ Q: U' u! ]* y7 J
6 C, f9 i1 W9 m( N
#if UART5_FIFO_EN == 1
( ]3 Q) r% ^# m; E( J
#define UART5_BAUD 115200
% u8 `4 B' @* W/ G" m J
#define UART5_TX_BUF_SIZE 1*1024- _2 w8 g1 q7 |; `% C
#define UART5_RX_BUF_SIZE 1*1024
5 ]8 k9 x) w* H6 |
#endif
* ]7 L2 r( r y/ {* G6 u
) x! j( Z2 |% C5 t! L" x0 _
#if UART6_FIFO_EN == 1, f- T0 \% H" j- P
#define UART6_BAUD 115200
2 r H7 ]% x4 G8 Q. z. r
#define UART6_TX_BUF_SIZE 1*1024
5 e+ R3 f' g# n4 _2 {" O( h
#define UART6_RX_BUF_SIZE 1*1024" Y2 e( X# W0 w2 @3 r! m
#endif, I: k* f9 v l! q% @- Z% T
+ i: L/ s, h" h. j- x: {: T' E# j
#if UART7_FIFO_EN == 1
6 s4 ]1 g8 D" s
#define UART7_BAUD 115200; Y) ~3 ~6 h* a7 X3 q6 q
#define UART7_TX_BUF_SIZE 1*1024
' \! b; Z0 b& ?/ M* t) e$ b6 B( H
#define UART7_RX_BUF_SIZE 1*1024
9 K9 q/ W8 j$ E/ S
#endif! s9 E ?' |: L0 T8 ?2 D
3 @7 r3 B" ?+ i# P. D: T3 X0 S
#if UART8_FIFO_EN == 1
. T% |" N" Q) t; s( K4 l$ G' A
#define UART8_BAUD 1152001 e: ^+ f# f$ G8 G
#define UART8_TX_BUF_SIZE 1*1024% U0 T. m- l4 w4 H' p
#define UART8_RX_BUF_SIZE 1*1024* y5 Q0 u. {& S7 Z5 G, k2 T$ P
#endif

复制代码

第3步：配置485 PHY的收发切换引脚

/* PB2 控制RS485芯片的发送使能 */" O1 h4 |; R/ q) \3 k5 N) q
#define RS485_TXEN_GPIO_CLK_ENABLE() __HAL_RCC_GPIOB_CLK_ENABLE()
/ ~: i8 R1 l8 @( t7 z
#define RS485_TXEN_GPIO_PORT GPIOB' S" Z6 d! U, r4 B0 h# Q( x
#define RS485_TXEN_PIN GPIO_PIN_2
. w' t, u& C2 i; o, m6 c
' i \" d5 K* y2 t$ E$ j* |
#define RS485_RX_EN() RS485_TXEN_GPIO_PORT->BSRRH = RS485_TXEN_PIN
/ L8 E! {2 x3 `, O q
#define RS485_TX_EN() RS485_TXEN_GPIO_PORT->BSRRL = RS485_TXEN_PIN

复制代码

第4步：根据使用的串口，配置下面函数的几个参数成员，下面是以串口3为例说明（置红部分）：

static void UartVarInit(void)
6 F* P0 s. @: x6 Y
{
1 [& C/ ^1 H9 W. ~& c, K$ r+ F
3 k2 ?; K9 D6 |
#if UART3_FIFO_EN == 1
5 w/ O; W1 n' `$ u" {
g_tUart3.uart = USART3; /* STM32 串口设备 */* P: `1 D0 J( u6 |* G2 H
g_tUart3.pTxBuf = g_TxBuf3; /* 发送缓冲区指针 */& X, |; A9 v9 N
g_tUart3.pRxBuf = g_RxBuf3; /* 接收缓冲区指针 */
( e0 k: K' T; d: N: X0 x' _
g_tUart3.usTxBufSize = UART3_TX_BUF_SIZE; /* 发送缓冲区大小 */2 e! _' T3 o/ v! x2 R* p. X
g_tUart3.usRxBufSize = UART3_RX_BUF_SIZE; /* 接收缓冲区大小 */4 W6 s0 U6 q% x7 x; A+ X
g_tUart3.usTxWrite = 0; /* 发送FIFO写索引 */
H7 N4 R) e$ p
g_tUart3.usTxRead = 0; /* 发送FIFO读索引 */
0 _* \3 {% Z! ]/ j3 y
g_tUart3.usRxWrite = 0; /* 接收FIFO写索引 */
$ y7 M, Y7 p# V! K, k' ~; G' g8 v
g_tUart3.usRxRead = 0; /* 接收FIFO读索引 */
, ]/ _( g; w7 h
g_tUart3.usRxCount = 0; /* 接收到的新数据个数 */- A6 B9 m% a0 C9 |; s
g_tUart3.usTxCount = 0; /* 待发送的数据个数 *// G k8 i5 a6 x$ Y: r4 D
g_tUart3.SendBefor = RS485_SendBefor; /* 发送数据前的回调函数 */
7 Y; y2 L3 r; m2 }5 d1 J1 G
g_tUart3.SendOver = RS485_SendOver; /* 发送完毕后的回调函数 */* C6 o1 E8 N7 G- z
g_tUart3.ReciveNew = RS485_ReciveNew; /* 接收到新数据后的回调函数 */5 x p( \- |, v C3 ]
g_tUart3.Sending = 0; /* 正在发送中标志 */
5 G) }& Z2 F( {3 {1 p6 y, `
#endif. F* F3 [$ |5 J0 E/ R H
}

复制代码

第5步：这几个驱动文件主要用到HAL库的GPIO和串口驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
第6步，应用方法看本章节配套例子即可。
31.7 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

  第1阶段，上电启动阶段：

这部分在第14章进行了详细说明。
  第2阶段，进入main函数：

  第1步，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器，LED和串口。
  第2步，485应用程序设计部分，具体分为两个部分，接收命令和发送命令。
31.8 实验例程说明（MDK）
配套例子：

V7-016_RS485多机通讯

实验目的：

学习RS485多机通讯的实现。
实验内容：

由于通信距离较短，SP3485E芯片上缺省未贴的电阻不需要贴上，大家可以根据需要贴上电阻做测试。
本例子支持多个485节点，不需要设置主设备和从设备，所有节点下载此程序即可。
开发板的485-A端子连接到一起，485-B端子连接到一起，具体连接看工程Doc文件夹中的截图。
实验操作：

按下开发板上的K1键点亮LED1，松开熄灭LED1，同时打印按键事件到串口1。485总线上的其它开发板做相同的动作。
按下开发板上的K2键，启动50ms的自动重装定时器，每隔50ms翻转LED2，并向485总线上的其它开发板发送按键K2按下消息，从而也实现每隔50ms翻转LED2。
按下开发板上的K3按键，停止K2按键启动的50ms自动重载定时器，485总线上的其它开发板做相同的动作。
按下开发板上的摇杆（上下左右，OK共5种），会通过串口1打印摇杆事件。485总线上的其它开发板做相同的动作。
注意事项：

RS485 PHY的发送使能用的引脚PB11，测试前需要将板子J5处的跳线帽短接到PB11端。
多机接线效果：

上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1

程序设计：

系统栈大小分配：

RAM空间用的DTCM：

硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：

/*
$ `" }7 j- P( h2 D! P: J$ |6 W7 u
*********************************************************************************************************( }! w; @% M9 }# L" l, H1 i7 O
* 函数名: bsp_Init
2 g% }" B( a# s1 Y
* 功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
* N/ \! t+ u3 ~$ Z
* 形参：无& @- l7 D$ _7 y5 ]& y# s* ^$ n
* 返回值: 无% J+ c4 h" P1 u! ~' p+ |
*********************************************************************************************************6 N$ i- H' j) `9 e P( t. g
*/
# @/ S6 o* X+ Z* n$ p7 |. }% T
void bsp_Init(void)
/ \( K n7 J9 r/ ^0 O3 p
{
0 `0 N E+ ]1 d. Z0 o8 f0 N
/* 配置MPU */
, H8 F. E' \* {" V! v
MPU_Config();
' G7 q" {& I7 P. I, ]+ x
' J7 _' X5 G) A$ Z
/* 使能L1 Cache */5 ^, `+ V r" \" ~2 f/ j
CPU_CACHE_Enable();1 ?1 y+ Z$ P& S; h* o
4 G, A0 t9 P, {8 |5 z* E4 b) D
/*
) O: c+ M0 U; h
STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:6 J5 @8 `8 X0 b+ ]
- 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
p1 B* D$ p" E
- 设置NVIV优先级分组为4。
4 E0 a: r; P3 E& g- K4 S
*/
: O. \0 J9 x6 ~( ?5 S9 N
HAL_Init();5 k' v9 b: s; i/ B% |3 }1 k$ Q
8 a9 t! n9 I- w9 i0 \. k
/*
9 I; H @5 a8 g! Q% w: E! q! J% ~
配置系统时钟到400MHz! a) }* J+ o5 ^
- 切换使用HSE。
V% H1 F$ H) u8 V" ]' T# e$ i
- 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。0 J3 |9 y- m: Z9 H
*/9 \ i& W: | ~4 N* P% Y
SystemClock_Config();- \0 h, K+ v0 x" A* ^3 ?6 ~! P1 k" ?
1 l; o* R( L/ a, f
/*
+ X) Q- N, m6 I) d
Event Recorder：( D! R, u, [; m1 M! r9 G
- 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
, i8 H# ~* x1 | a$ ]1 W
- 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
, d3 p4 A' v1 x2 n* V/ g
*/
) [4 z6 \% ^% f
#if Enable_EventRecorder == 1
* h. A: ^9 r0 [0 x/ n3 A
/* 初始化EventRecorder并开启 */* B A! c) v% c f: h3 j2 w+ G' a
EventRecorderInitialize(EventRecordAll, 1U);+ f% W c6 p+ a$ X& g
EventRecorderStart();
+ {# W9 D. ^' H4 g0 G& {/ d" T8 y
#endif
/ k9 ~8 v8 U7 U8 Q+ z; S
+ N. Y) P @, ~9 i$ T4 r) Z
bsp_InitKey(); /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */9 t; X; d3 ^/ W' i/ D ]3 F
bsp_InitTimer(); /* 初始化滴答定时器 */7 G- i7 \$ b& Q' d& q
bsp_InitUart(); /* 初始化串口 */5 j4 i; e, h6 ]: X. f) I) t
bsp_InitExtIO(); /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */ ) r! |( a+ Q4 W6 L) c0 n0 v
bsp_InitLed(); /* 初始化LED */ * |6 x# g- T1 U3 W9 z1 n2 L
}

复制代码

MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

/*
& b: N- C( x) \ K( [4 Y$ l+ p
*********************************************************************************************************
9 t: t' N3 i: g1 Y2 o1 A
* 函数名: MPU_Config7 d; s+ i7 j. d. s9 E
* 功能说明: 配置MPU/ a! V, h2 Z! ~, B9 R: t" i* ~: O
* 形参: 无9 b! v$ o& q/ Q9 J
* 返回值: 无
3 i* L8 |, H& B" _, i, s
********************************************************************************************************** f$ u/ S! g& b! @ _( A& I
*/# V* {$ W' k9 J( |8 R9 n8 t
static void MPU_Config( void )9 f, K" N8 g0 X+ Z
{& B0 H2 H+ @* F' Z
MPU_Region_InitTypeDef MPU_InitStruct;" _. Y1 V* `) D1 \0 x( D, z
+ P; T' w( Y3 E9 q9 q
/* 禁止 MPU */. j- d/ W; U4 u& P4 e
HAL_MPU_Disable();( G- S1 V& v/ L9 l, M4 O
+ x) O% G7 R2 Y! X- F: R
/* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */7 [% E% |- G+ s
MPU_InitStruct.Enable = MPU_REGION_ENABLE;
/ R; ^9 B3 z! P, }2 L
MPU_InitStruct.BaseAddress = 0x24000000;8 y" Z1 F0 C! W, S; G
MPU_InitStruct.Size = MPU_REGION_SIZE_512KB;" \& J1 g) m% g+ A4 W5 F' e
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
; E) |8 V# A/ y( [( T
MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE;
3 ]$ g. s5 s B% U, D* Y6 j* t0 J
MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;! r7 B- z" P! @3 b# M9 K
MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
( M: r% @& q% T4 \
MPU_InitStruct.Number = MPU_REGION_NUMBER0;
! v+ s# c( W8 y Z
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL1;
7 f- v: P9 z- h: X$ v7 c# t6 H
MPU_InitStruct.SubRegionDisable = 0x00;$ U8 c2 A. T/ v1 e2 m+ U
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;+ v! n: f# t% M2 w
% f/ j+ E! t: E( Q. h
HAL_MPU_ConfigRegion(&MPU_InitStruct);* Z5 E& z* w1 D5 f
0 q- X: g2 h) b5 R
. x! {$ }7 d* |) i& ]( j, q' t
/* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
4 k, C" {: }9 k2 C" Q
MPU_InitStruct.Enable = MPU_REGION_ENABLE;
& k2 u0 ?4 B. n/ T5 b
MPU_InitStruct.BaseAddress = 0x60000000;
# Q! U" q) z5 ?
MPU_InitStruct.Size = ARM_MPU_REGION_SIZE_64KB;
; T' U; \+ t: M' B$ R
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
8 G$ K" r2 |$ B2 y( x
MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE;
$ W0 A ~% l0 g- Q9 R- @
MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE;
+ B( g+ b' `( Q- M7 P0 {
MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;9 H2 p; u# C* y1 N" F
MPU_InitStruct.Number = MPU_REGION_NUMBER1;
9 ]0 R: X' N* @
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;3 B1 |4 K) U: g: b% W! R( G6 u7 e
MPU_InitStruct.SubRegionDisable = 0x00;* E1 }6 z1 _' F/ v- H+ P0 h
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;8 F1 m G* i2 t. O( Y/ H7 d
" {" z$ _# g# p, G" B# b; u; r
HAL_MPU_ConfigRegion(&MPU_InitStruct);
9 V) O3 q. @0 |# t8 o4 t9 [# V
3 W( U: m% P1 R3 \& X+ b7 [
/*使能 MPU */
! U. Q. Y! U% g( s! m0 ]
HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
- T9 S. f. H5 U: t1 u+ F
}# L0 n! T b2 x- j3 _
3 q; b8 K% A+ H+ A3 F. L
/*
- L i- z, M6 s/ P3 n+ E U
*********************************************************************************************************3 s! D: F! o/ K8 k$ u `
* 函数名: CPU_CACHE_Enable
; q3 R) T4 d6 H9 P$ C
* 功能说明: 使能L1 Cache- r* _; E, w: j, c8 i1 Z5 ~
* 形参: 无" \( Q2 Q. p& f9 O& A, j* H+ L: M7 C2 S
* 返回值: 无
* E/ i- o$ I$ T8 |
*********************************************************************************************************
6 a" D2 r9 j" f o3 \1 R: Z3 Q
*/
) l+ [- A- n2 p1 k4 L
static void CPU_CACHE_Enable(void)& d$ a. t) F( X* \. |* F0 }
{7 {- l) e# d5 T& t. K/ N7 q
/* 使能 I-Cache */
[4 H N. @: ?. \! d# y% Y
SCB_EnableICache();, h. _; F, O. G9 R, E( i( b
. I, t2 Z# U' T& u
/* 使能 D-Cache */" ?7 z4 l" V3 v! j9 B8 m) t7 S
SCB_EnableDCache();
8 G) w7 |) v7 [/ H1 D3 e+ O& i
}

复制代码

  主功能：

主功能的实现主要分为两部分：

  获取其它RS485设备发来的命令，并执行相应功能。
通过函数comGetChar(COM3, &ucDataTravel)以查询、非阻塞方式获取其它开发板发来的数据。

  根据不同的按键消息，向其它485设备发送命令
通过函数comSendChar(COM3, ucDataTravel)以非阻塞方式向其它485设备发送命令，以此来执行同样的功能。

/*9 `) Q" q/ [* c( Q) A( I" U% H3 Z
********************************************************************************************************* w# V4 }1 q# p7 k! f
* 函数名: main
9 e$ s2 _" [" w% ]( c! I8 f7 x; I
* 功能说明: c程序入口3 z2 W% t. W, }) O
* 形参: 无) z6 H; C9 P$ n2 j; e
* 返回值: 错误代码(无需处理)
& M; B" ]* u, |" w D
*********************************************************************************************************
2 E0 A! R' D1 Y. {2 U
*/
1 x2 F+ F/ F4 d$ f$ w
int main(void)
; n! @, M% v2 N6 ` a
{! `0 P2 ?, b/ A6 w6 K# W
uint8_t ucKeyCode; /* 按键代码 */ g6 e7 Z' l" y9 q2 k6 L) I0 [
uint8_t ucDataTravel; /* 发送变量 */& U- L/ H9 @7 x4 l5 Z' u
uint8_t ucDataRec; /* 接收变量 */
2 e# ^8 b, y) b/ Z3 e+ Z/ B
' S: q1 ?: i) k1 T3 |3 z1 _
bsp_Init(); /* 硬件初始化 *// ]! v* ^% l, w& _0 P! p
: D6 Y. Y9 b% F2 g/ l
PrintfLogo(); /* 打印例程名称和版本等信息 */
8 k7 H; U7 M* b W* N" a4 N P! e
PrintfHelp(); /* 打印操作提示 */
+ Q, i: u8 J" _. e
6 m0 g- d( J% C f( ~$ r2 H
/* 进入主程序循环体 */
7 p: K4 p- m, b+ S
while (1)
4 k$ ?8 o! `7 Y; W* b# F
{
" a; w+ b- v& r: a) ~) V) F s% s4 R
bsp_Idle(); /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
& M6 W7 q6 E7 _; G& F+ q# p
$ ]; {" H# x5 H) V* W" Y4 o7 R$ O
/* 获取其它开发板通过485总线发来的数据 */
# ?6 q. u; ^: ?) Z
if(comGetChar(COM3, &ucDataRec))
: T- I+ l/ Y- A+ f0 n j
{
+ r8 z4 W- E' u
switch (ucDataRec)
! z# R7 m+ p4 U; g# P9 l: G" {
{
2 B8 A/ i7 H; N5 M7 o
case KEY_DOWN_K1: /* 获得K1键按下消息 */
0 W5 \ D) l+ D
bsp_LedOn(1);
9 y5 D1 o( ~7 D0 l) \# ~' S
printf("K1键按下, LED1点亮\r\n");( m# ?; I) A1 m7 v
break;
2 x4 |% H( Y1 T
( ?% S/ \2 n# p* c
case KEY_UP_K1: /* 获得K1键释放消息 */
& y/ x; | h0 T, b
bsp_LedOff(1);1 U$ a4 e! t# W" b+ X
printf("K1键弹起, LED1熄灭\r\n");5 b0 F1 r; M7 ^' q W; i
break;1 P. _0 |) q0 X) b
, p( X M% z' ?; w" \$ E* n6 P
case KEY_DOWN_K2: /* 获得K1键按下消息 */
" [ }* i! L* H x: z" w' i3 U
bsp_LedToggle(2);
* V `( l# R' z8 [$ U6 G7 g8 _
break;$ ]# {6 z' {$ u( e; `
5 s7 N4 c7 H D2 j0 a. m
case JOY_DOWN_U: /* 获得摇杆UP键按下 */2 T5 G; B |" P2 [( z- ?
printf("摇杆上键按下\r\n");
& ?$ M$ ]+ I/ v H5 Z- o; q E
break;
+ v. T$ W- {1 G' y0 Z6 x5 o
9 |& P* d6 Q$ \) F* y
case JOY_DOWN_D: /* 获得摇杆DOWN键按下 */
2 P: a, l1 [" f9 t, l3 ]4 `2 m6 J
printf("摇杆下键按下\r\n");# ?5 y! D( M4 Z% ^
break;
0 Y7 X& T3 `+ U1 m. n
# o; f& Y) i# E
case JOY_DOWN_L: /* 获得摇杆LEFT键按下 *// @% Q$ u0 y. \+ A
printf("摇杆左键按下\r\n");
0 n( t0 v: h0 S# @, ~
break;
4 _$ O; q* L& o0 Y# I; g7 q
' p+ G! v. l+ a% n+ D
case JOY_DOWN_R: /* 获得摇杆RIGHT键按下 */! L' [9 J, U$ _( l
printf("摇杆右键按下\r\n");
, Z4 l/ ?& c5 N$ Z% s
break;
) W1 |$ r# K4 [0 A+ t: V( k! o
6 ]* \& }- x) ]: k, t- ]
case JOY_DOWN_OK: /* 获得摇杆OK键按下 */6 R) ?4 K2 F" V) F( l* b' J& P- E
printf("摇杆OK键按下\r\n");- X/ X2 l- x" c N" K {
break;0 P: a( n- G" Z. L( c5 D
+ T: m& }& B R/ t" s2 \" i, g# `
case JOY_UP_OK: /* 获得摇杆OK键弹起 */ F' b( a. `. [- T. A- `
printf("摇杆OK键弹起\r\n");& e* ]& G; N$ A8 X# @
break;6 }" L* H; j3 a4 Z" c& a# y
( F) |+ o* z5 ^: \+ k" T/ ^: }
default:% u# n3 f& s# a& I
/* 其它的键值不处理 */+ Q( a9 Q7 ` j7 N
break;2 y i: f5 j1 r8 E- O' v
}
/ d; u" o' g3 U4 |# c
}
) r" y p2 x8 z: _/ P
9 q1 R: q# O1 s$ u' N4 D& i+ x
/* 判断定时器超时时间 */
7 N# c2 ]) A+ n; x1 X% I
if (bsp_CheckTimer(0)) 9 K; Q$ b6 C9 F7 n) W# b" R
{
( ~8 _& a% S: Y, ?1 E& R. T* r
/* 每隔50ms 进来一次 */ 2 O. K' g1 [6 ^# z0 U5 _) g
bsp_LedToggle(2);; V+ Q9 H+ a- V8 @. z
/* 向其它开发板发送按键K2按下的消息 */
) ^# L" d. L W, X- z v: B
ucDataTravel = KEY_DOWN_K2;2 u; j) e$ w, E
comSendChar(COM3, ucDataTravel);' r3 K- P! q: L( M' B+ e( ]
}
$ C. {5 Y3 z9 S
1 Q- |; r# ~+ q! Z
/* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 *// n: P; J! m$ n( C7 {: f5 Z' H
ucKeyCode = bsp_GetKey(); /* 读取键值, 无键按下时返回 KEY_NONE = 0 */# j' I. |/ W; W) Q( ]
if (ucKeyCode != KEY_NONE)3 {4 k0 O8 A* p# V0 x0 a
{; |" m% a6 A& L. O
switch (ucKeyCode)4 g" U- ?1 N) k: p) C, o4 J
{
. W6 _% l# c$ g( t
case KEY_DOWN_K1: /* K1键按下 */' D1 O0 X" R) S& M+ m9 j# x
ucDataTravel = KEY_DOWN_K1;' [' [% B: z. c
comSendChar(COM3, ucDataTravel);: L; c& z/ i4 b% R6 A$ h" G
bsp_LedOn(1);" @/ I: ^0 L, K# z' T2 X4 T, A4 w! m
printf("K1键按下, LED1点亮\r\n");- V* ^; `. {9 h' M* G
break;# j% }& a9 E3 N6 L
! X: b/ e' {( `; \' E
case KEY_UP_K1: /* K1键弹起 */
0 W8 m2 m/ Z. b6 p
ucDataTravel = KEY_UP_K1;
1 @- Z- v) k7 h9 J
comSendChar(COM3, ucDataTravel);1 O" Q1 h+ ]5 s' c; Q' x* O
bsp_LedOff(1);% z. [2 ^" C) \* P0 |
printf("K1键弹起, LED1熄灭\r\n");/ i: M0 s; B1 @; S# g, u' M) I/ J
break;7 J1 Q8 T9 J6 C9 l
8 [& `7 R5 g4 n" v
case KEY_DOWN_K2: /* K2键按下 */
3 I: W, g9 C7 z. ^6 b
bsp_StartAutoTimer(0, 50); /* 启动1个50ms的自动重装的定时器 */& i" J6 R j4 v% [
break;1 r5 ?2 t! k. i2 ?& z$ ^
0 {2 L* A" o1 |4 ~1 {( @; _% c
case KEY_DOWN_K3: /* K3键按下 */+ l' ?" L! U- n
bsp_StopTimer(0); /* 停止自动重装的定时器 */
" v8 j2 x5 }. \
break;" @$ T( M! ~& @: Y% A: s B% _
, T+ _7 T6 o/ @5 g5 c
case JOY_DOWN_U: /* 摇杆UP键按下 */6 }1 s; s! }1 p: A1 o+ U
ucDataTravel = JOY_DOWN_U;
6 K5 L9 ^) ]$ \! U k
comSendChar(COM3, ucDataTravel);
/ K: {9 \" D$ T% g, [" @
printf("摇杆上键按下\r\n");- J5 d* O6 n7 O7 E; {4 q! ]
break;
8 h8 ]' j5 o( L2 y4 s! t% d
. L% _. F( A% y$ s- b
case JOY_DOWN_D: /* 摇杆DOWN键按下 */8 Z: v' c" Q# b, u$ g
ucDataTravel = JOY_DOWN_D;3 N5 W/ ^6 P/ @+ O
comSendChar(COM3, ucDataTravel);' _# a( G3 A) Z( U$ s4 ^6 ~
printf("摇杆下键按下\r\n");$ [2 G/ D9 U D
break;
5 }, h$ ?- B& d
7 ~# B/ e" H1 A$ p4 _$ w& ^7 d
case JOY_DOWN_L: /* 摇杆LEFT键按下 */
1 M' A6 w% B B2 C' T* t# f
ucDataTravel = JOY_DOWN_L;+ i; u! W1 Y# p
comSendChar(COM3, ucDataTravel);
+ S0 o. s( o, X/ `) I
printf("摇杆左键按下\r\n");
4 m4 q8 H! h2 \
break;
6 Z! f+ e! N' j, w4 e
- d8 \, \( D9 Y" w1 w1 q9 m
case JOY_DOWN_R: /* 摇杆RIGHT键按下 */
( F7 h& j* h$ ?
ucDataTravel = JOY_DOWN_R;! V x& m# a$ u m2 B
comSendChar(COM3, ucDataTravel);9 z3 R5 h; I3 A- {
printf("摇杆右键按下\r\n"); |* u$ C" Y# e: [; J- S: T
break;* L# Q0 ?; j& \% M% i1 d/ h* ~# h
% j$ c% i) {3 g) M) x9 n; v
case JOY_DOWN_OK: /* 摇杆OK键按下 */4 S2 i$ g7 j/ B1 m( w
ucDataTravel = JOY_DOWN_OK;
4 w/ D$ J! d6 N% z
comSendChar(COM3, ucDataTravel);$ R/ ~5 v& K+ S* L, Q
printf("摇杆OK键按下\r\n");
+ U) _/ Y( ^; Y* v0 A
break;8 l( l( N& ?% y2 B/ e- }2 Z* M+ a
/ |$ ?0 ~& X7 _3 d3 ~1 C6 [; k
case JOY_UP_OK: /* 摇杆OK键弹起 */* ^8 v6 X0 j) x5 v4 ?
ucDataTravel = JOY_UP_OK;
3 R* z: j* T: r. v, @0 ^
comSendChar(COM3, ucDataTravel);
8 R/ [9 L& b/ {4 I: q1 _9 O
printf("摇杆OK键弹起\r\n");- _/ V; K5 i- Q6 o$ B" J
break;
8 u7 F) L" @7 T: F3 ?4 {
1 x) D/ j" X$ O3 Y
default:
) n& a) X+ `( R/ J
/* 其它的键值不处理 */# }8 R6 t$ F" @5 P8 c) G# i
break;4 E: j) _4 X- P G
}2 E' N; r3 D/ E0 f! B9 f
}
6 d& W6 {, @8 q/ F# T! u( x: w
}
4 V3 R( v& Y7 |6 U
}

复制代码

31.9 实验例程说明（IAR）
配套例子：

V7-016_RS485多机通讯

实验目的：

学习RS485多机通讯的实现。
实验内容：

由于通信距离较短，SP3485E芯片上缺省未贴的电阻不需要贴上，大家可以根据需要贴上电阻做测试。
本例子支持多个485节点，不需要设置主设备和从设备，所有节点下载此程序即可。
开发板的485-A端子连接到一起，485-B端子连接到一起，具体连接看工程Doc文件夹中的截图。
实验操作：

按下开发板上的K1键点亮LED1，松开熄灭LED1，同时打印按键事件到串口1。485总线上的其它开发板做相同的动作。
按下开发板上的K2键，启动50ms的自动重装定时器，每隔50ms翻转LED2，并向485总线上的其它开发板发送按键K2按下消息，从而也实现每隔50ms翻转LED2。
按下开发板上的K3按键，停止K2按键启动的50ms自动重载定时器，485总线上的其它开发板做相同的动作。
按下开发板上的摇杆（上下左右，OK共5种），会通过串口1打印摇杆事件。485总线上的其它开发板做相同的动作。
注意事项：

RS485 PHY的发送使能用的引脚PB11，测试前需要将板子J5处的跳线帽短接到PB11端。
多机接线效果：

上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1

程序设计：

系统栈大小分配：

RAM空间用的DTCM：

硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：

/*: }$ |' m, ]+ L2 {- L7 i) Q
*********************************************************************************************************
$ y) e C) X% w V
* 函数名: bsp_Init5 I" e/ o8 {- N* N; M& k5 g; }
* 功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
8 ~ z- b- ?6 j
* 形参：无
4 F) G6 {6 L' y
* 返回值: 无# j) R$ C. U* k/ o2 d6 R) m7 w
*********************************************************************************************************
+ V' P) a# o6 V. p, M9 H7 S6 Z
*/
4 Q/ v' |! Y$ |$ l
void bsp_Init(void)
* G, Q5 J" i9 h
{
. O/ N6 ^! R5 s ^: p1 d- Q
/* 配置MPU */: p; |* Y" L- Y9 o" Q( m
MPU_Config();0 O+ ?$ |# r8 S) V; K! ]2 }
$ V8 e- k2 N! B6 z1 u
/* 使能L1 Cache */
+ Q, d; y1 w! Q
CPU_CACHE_Enable();8 ]2 I D. Z. a: e5 _8 ]
, k4 C- d' h, z8 [. ^6 K$ f
/*
6 ]% P( P3 N, }, l( y7 W3 F
STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
: s* @: b& v# W4 G
- 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
" a+ W% Y$ L% U! U3 x7 ^: `; d3 A
- 设置NVIV优先级分组为4。
5 a7 l/ L! F, l* j
*/6 r3 K% [1 ^2 r$ d2 T/ l% K
HAL_Init();
+ U) o$ X% L* Y) I* I
/* " U$ U7 h0 ^+ I2 }, w
配置系统时钟到400MHz5 K9 ]" b/ Z" R0 [( C
- 切换使用HSE。: k7 Q6 x; A/ `8 t3 w- N
- 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
, @% d% k2 L5 q4 I3 ?) i L2 J3 |
*/
+ n) ], y8 J( v& q' T! W0 {
SystemClock_Config();6 }- J! z) f ]
! ?9 L, x* Q* u- @8 ?! \
/* 3 {* J+ G6 g) c8 c$ K
Event Recorder：# o0 [9 t5 y3 p' V7 H6 e
- 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。& \, X/ O6 C" G7 v0 P) ] n$ h
- 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
. N/ E \8 ?# Z& V. s v
*/
" S1 h9 P/ |8 }/ C0 z
#if Enable_EventRecorder == 1 , ^ A1 I# T1 p2 u# [0 W2 ^
/* 初始化EventRecorder并开启 */( H |5 ^& A- E% V6 {- p. r
EventRecorderInitialize(EventRecordAll, 1U);
/ _; g; [* i' \6 E9 V$ D' ^
EventRecorderStart();, x( V: h" B% k- K7 }( ` Q: }* a# [7 j8 G
#endif; G6 R) @) U" S4 O& ^% }( y9 b
+ z, p5 H5 B) ?+ I9 W L4 s$ Y& Y
bsp_InitKey(); /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
+ @) E2 O# Y2 W) ` }( L/ Z4 |
bsp_InitTimer(); /* 初始化滴答定时器 */
' K3 K0 @( x2 p. Z; }3 Y3 U
bsp_InitUart(); /* 初始化串口 */
' v% }! }; z" u# w1 I
bsp_InitExtIO(); /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */
F8 r& U0 M. g1 q' U; C& U* ^
bsp_InitLed(); /* 初始化LED */ 3 x8 H9 M9 c7 p# \
}

复制代码

MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

/*
% I( Q6 F3 r( U& M
*********************************************************************************************************
" R( e# u. K; X! F7 Z9 I7 P
* 函数名: MPU_Config
" K. V1 Z: n+ Z0 E8 ~
* 功能说明: 配置MPU
z& y. A$ R' @! D' k8 N3 Z
* 形参: 无
$ V$ V6 |) a9 S0 x* j: b
* 返回值: 无
) `- i' d4 J, i- t: w4 G9 w4 R
*********************************************************************************************************0 E9 I' o' l: ^- \* L- p
*/
3 W" {( q* ~6 H( s# Q R) N0 B
static void MPU_Config( void )7 N- ?3 a# V# d! R g" [0 S8 R
{5 T3 h0 |+ A( g' W) Z0 \# Z2 |0 m
MPU_Region_InitTypeDef MPU_InitStruct;! R0 o; o0 } F; U
& t2 {; j; o# M/ F+ E/ N- F9 V9 S
/* 禁止 MPU */
6 j8 D# |7 H* e/ |- \
HAL_MPU_Disable();
1 _8 J& g- x+ E2 E# F: X( P2 G
* ?4 @% q' {7 S; |8 T1 Y
/* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */2 S4 W, ?9 n- i( ^
MPU_InitStruct.Enable = MPU_REGION_ENABLE;% V3 U* s) O- h2 d. r, P4 k
MPU_InitStruct.BaseAddress = 0x24000000;2 y& M, @1 F8 y* s4 _( L
MPU_InitStruct.Size = MPU_REGION_SIZE_512KB;
4 a k& m9 [( B5 E
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;8 }0 z) F( s, t
MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE;
: a! H5 n3 E4 g: c( c) p3 s2 t
MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;6 J, t Q! J6 ?; C: v
MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
9 ^& r$ N; L( T& K, j5 o' B0 m
MPU_InitStruct.Number = MPU_REGION_NUMBER0;
( }' v2 a8 c+ `9 c
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL1;
0 n; @( b1 {" g# O! P8 r* k
MPU_InitStruct.SubRegionDisable = 0x00;
# m% p: e( @( w' n! S
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;
! n2 `( D$ ~/ L; z* [( j+ C. r& c
6 N" T9 G7 |' S+ a; S0 y* i, B A
HAL_MPU_ConfigRegion(&MPU_InitStruct);+ a# t( g$ H0 S" b. x' T
5 x3 k: X, ?5 v/ I5 s+ z7 [8 h
: ^$ Q) q; I" ]3 G0 t# T5 d
/* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
6 l. D3 P* ~8 Z, o( u0 v
MPU_InitStruct.Enable = MPU_REGION_ENABLE;, E+ z- e3 Y$ H! ?3 x( H
MPU_InitStruct.BaseAddress = 0x60000000;
2 e: ]$ v- R$ i2 V3 S3 h' [
MPU_InitStruct.Size = ARM_MPU_REGION_SIZE_64KB;
; n, L, [; h7 [$ y
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
6 V! V5 Q) A; B5 Z: p* h
MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE;
% D% d$ V6 j' Z5 E) j
MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE;
3 x, g1 I, c0 c) {; b$ w0 Q& k9 v
MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
+ k9 w, e' c8 k
MPU_InitStruct.Number = MPU_REGION_NUMBER1;
7 q5 H* p8 z2 [3 l7 E
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;( f8 v0 ^& h4 Q* u+ w# S+ |4 M
MPU_InitStruct.SubRegionDisable = 0x00;
8 J5 I' T7 M2 f7 p9 G) \: p
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;0 c2 ^5 v% L6 W
7 ~$ C/ V r: u {9 g9 t
HAL_MPU_ConfigRegion(&MPU_InitStruct);
t$ [ n5 U$ J! S6 \; k
' G& P& W% ~2 q' M5 D
/*使能 MPU */
# v# k. b) i' X7 Y
HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);( h X4 ?- [" I3 [6 B! y/ w- Y# Z
}
" q; i( n1 [; J+ x7 r3 m: z
% ]7 j* e$ i! |+ a1 h0 T5 ^
/*
5 w5 M) I9 W3 u! B- Z& W
*********************************************************************************************************& L) ^) K/ A( L' u
* 函数名: CPU_CACHE_Enable! W$ x! T3 f( R. i5 R# {) E2 M: l3 K/ r
* 功能说明: 使能L1 Cache
. O+ ^2 i2 A* @/ t8 _ H: ~
* 形参: 无
6 P ?- j' K' z* `4 r1 T9 l
* 返回值: 无
- P ?+ X/ F4 H2 i
*********************************************************************************************************
) w) B/ L" V- ]2 S3 W
*/! h) r2 `% W3 K0 U
static void CPU_CACHE_Enable(void)5 O) j+ ~0 A& o9 X, D
{
! X3 Q9 V( v% F% i2 f
/* 使能 I-Cache */8 A, N* {' C8 L5 h
SCB_EnableICache();
4 c6 q6 ^- I- e3 ~
- ~7 i2 n* P. f: c- \
/* 使能 D-Cache */, G9 V/ K) W& `* x5 S
SCB_EnableDCache();1 l5 M" l' {3 K9 a% V2 C
}

复制代码

/*1 p$ L" Y% j+ `, |
*********************************************************************************************************: t. d( R4 W1 |) _* r" ^1 M. q% D
* 函数名: main
$ {+ J, T6 x+ L {9 H7 P
* 功能说明: c程序入口" [; L9 g6 W7 a. r
* 形参: 无/ m' Z) r! _# D
* 返回值: 错误代码(无需处理)
/ L, G5 a# Q |& `* E
*********************************************************************************************************
0 D+ n( g% M: h; R: R
*/
$ b5 n+ X+ U( L! M! Q2 l
int main(void)
6 U, W. _% Q- \+ u
{
. O4 h1 v+ Y7 D5 t( T
uint8_t ucKeyCode; /* 按键代码 */- T1 ^2 L5 C- p5 m$ Q
uint8_t ucDataTravel; /* 发送变量 */
4 f6 n, r+ j% w3 t0 k8 V
uint8_t ucDataRec; /* 接收变量 */
% y7 [! e/ c, z) R6 V) a! _: v" s
8 K# v5 L- r- W
bsp_Init(); /* 硬件初始化 */% G% {8 s+ I$ W8 z3 f+ _
" ^% @7 Q) k! a9 c; Z; k6 e
PrintfLogo(); /* 打印例程名称和版本等信息 */
7 D' s/ t' P" f; M0 m0 v2 Y; n
PrintfHelp(); /* 打印操作提示 */& J& y: `0 U* j" r0 G
3 C* |& ~/ L! e( b$ G& _+ r7 t
/* 进入主程序循环体 */3 Y# C& j0 b# Q7 y
while (1)
: ^' W: {( D8 c0 b
{/ S6 k' F7 w& m; @' ]$ H e- T
bsp_Idle(); /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */* h, `* N( j1 J& @) I
E: ~0 H p7 L d1 M/ O% W
/* 获取其它开发板通过485总线发来的数据 */
4 q& B1 G. d2 y6 A* d
if(comGetChar(COM3, &ucDataRec))! d! K' @4 r7 h: \& T3 @5 m
{4 o0 Q8 S0 j6 b5 l
switch (ucDataRec)
& V& W' Y' M9 u# g+ X* P$ f
{
7 k& T8 H. e, _9 V& W* V. E7 I
case KEY_DOWN_K1: /* 获得K1键按下消息 */
8 R3 U( X$ B" X; Q, R* d2 j6 c
bsp_LedOn(1);% g2 r5 s0 K7 I8 M2 [
printf("K1键按下, LED1点亮\r\n");6 K1 M% E% ?' `
break;
" L/ [/ o/ {# H X3 @' w9 P0 h
- h' f1 O+ u& T
case KEY_UP_K1: /* 获得K1键释放消息 */' V& d% e8 e3 G3 N& C6 r
bsp_LedOff(1);4 O$ z# k2 s Q1 `
printf("K1键弹起, LED1熄灭\r\n");
2 \! M0 G5 N. `" C
break;; c) \8 |/ U/ s& c- F% C# P
p3 ]6 @+ y* U: i) d5 U, |) z
case KEY_DOWN_K2: /* 获得K1键按下消息 */+ j) j6 D. z$ H; j$ Y
bsp_LedToggle(2);
2 r% S# _/ s# a' | {7 U
break;
& {+ Z& B3 _: A- I5 u
0 B, J, {& ~+ {! x
case JOY_DOWN_U: /* 获得摇杆UP键按下 */0 ` Q; Y# {1 U
printf("摇杆上键按下\r\n");6 }5 `# d1 P$ }, p, r$ ]
break;
- g2 H3 i5 t: Q+ j, m1 Z
& m1 b7 \* l# W. z
case JOY_DOWN_D: /* 获得摇杆DOWN键按下 */+ a, p7 H, R# Q$ y7 |' T( ` n
printf("摇杆下键按下\r\n");
9 B$ N6 o1 q- S" w/ K6 |1 N
break;
5 h2 {/ Y8 Q9 `2 A
; n0 c b8 k" u! V3 k# v* N
case JOY_DOWN_L: /* 获得摇杆LEFT键按下 */
$ M H- p" o% z, l! u
printf("摇杆左键按下\r\n");/ z* X3 O" U6 D
break;9 z* e. I, A: N6 W+ K6 _
6 D/ i5 g0 u5 ]" y# u7 K
case JOY_DOWN_R: /* 获得摇杆RIGHT键按下 */
2 m$ s& m1 j% t# }% Q
printf("摇杆右键按下\r\n");: m( M$ ]% p" U9 q0 x
break;
! _0 x7 x8 t* Q8 B+ G1 I1 W
+ g6 d2 H* C! _$ R& ~8 n/ O
case JOY_DOWN_OK: /* 获得摇杆OK键按下 */
% |$ f5 C( Y/ N8 L8 r/ |
printf("摇杆OK键按下\r\n");
! z. w, y3 |3 V) g
break;
3 m' b$ d" O5 S: L, D: m3 ]9 M: a
e& W! Z) {; `1 u& d
case JOY_UP_OK: /* 获得摇杆OK键弹起 */
! G9 o0 a E) U$ Z, u7 T
printf("摇杆OK键弹起\r\n");
/ [& s$ _/ T3 P# E! E
break;" R1 l0 @. f8 h; x8 O
1 Q' E) }5 Q- g2 a
default:
' M& U6 w% W' t% a+ @5 X+ {
/* 其它的键值不处理 */2 L6 g( y7 S1 u8 s) G+ \. O
break;
0 A3 [2 Y8 z9 u) a" w1 v
}+ V. b/ d/ w9 T8 D
}
- {: J- g! j9 S. ?/ U
1 p% q! D% k6 z! B& R) D. l
/* 判断定时器超时时间 */' i/ \0 I7 q3 c. m* ?+ x
if (bsp_CheckTimer(0))
) m5 w- A/ I" Y- U
{
9 W- d7 o+ _' l+ w4 H- u
/* 每隔50ms 进来一次 */
$ U+ [: ]: `1 W4 y- S
bsp_LedToggle(2); C7 N) x' U8 ?9 H! f" Q
/* 向其它开发板发送按键K2按下的消息 */
) t; v/ B( n3 L
ucDataTravel = KEY_DOWN_K2;
( y% J+ v2 ^8 @! N! |7 m- z8 S
comSendChar(COM3, ucDataTravel);2 a* q4 `: }( _
}" c# }7 a: t7 f1 }9 a: \
6 \! i! `' q6 O0 ~7 _
/* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */" Q) Y6 Q( ]# Y8 t3 o
ucKeyCode = bsp_GetKey(); /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
& I+ f- z( D5 l1 ~9 q: f" l' H0 r1 A
if (ucKeyCode != KEY_NONE)
2 l K( O% q6 y1 v4 _
{1 b. H; T0 H( l# L( W E
switch (ucKeyCode): i& i8 B1 t! i; A8 G1 L
{
7 Q* F1 |- O {; S* K
case KEY_DOWN_K1: /* K1键按下 */7 _2 }; \/ ]7 g+ f f7 W
ucDataTravel = KEY_DOWN_K1;
4 l7 ?/ L M; M
comSendChar(COM3, ucDataTravel); ? p, ?/ D2 O0 T3 ~
bsp_LedOn(1);5 {/ b& l( {0 P
printf("K1键按下, LED1点亮\r\n");. [5 U2 U+ T S" B( l
break;
& p M+ ~) o& {
* D% ~4 T1 \5 m
case KEY_UP_K1: /* K1键弹起 */
/ a2 J! G! p0 r) y" [; T h
ucDataTravel = KEY_UP_K1;
$ |; A; ?1 P8 }( Z, _1 o
comSendChar(COM3, ucDataTravel);
; l' I/ a# |9 M4 ]
bsp_LedOff(1);2 d0 G+ n. Z8 s- z
printf("K1键弹起, LED1熄灭\r\n");. `& p9 S, w O2 S) S& n! m) n, n
break;! v o. N/ R6 f" m* j Z. H( I }1 h
# D( V! t& ^% @' E7 e4 u% w
case KEY_DOWN_K2: /* K2键按下 */# d4 B+ f; b" e! M; j
bsp_StartAutoTimer(0, 50); /* 启动1个50ms的自动重装的定时器 */
! Z9 R2 D7 L5 M4 ], Q
break;
" C5 O2 T6 |& X4 h3 q
0 e w. r: L$ [! ?& u% w0 W
case KEY_DOWN_K3: /* K3键按下 */
( a( F9 Q3 L6 p& w
bsp_StopTimer(0); /* 停止自动重装的定时器 */
7 T. a, r" K, Z, z7 x% s# X3 m
break;
9 d' E9 e) @3 g4 k
0 m' Z' s, y2 S2 O6 a
case JOY_DOWN_U: /* 摇杆UP键按下 */
9 [: d( g7 N4 e- }# U! G9 ^
ucDataTravel = JOY_DOWN_U;
) R/ s: B& Y, Z0 {% {9 h
comSendChar(COM3, ucDataTravel);
% c' o3 r9 ~! Q; n" e) u
printf("摇杆上键按下\r\n");1 U" }; |( T+ @* H( C4 M8 m
break;9 N7 z( G9 T! t, {- N4 k
. G$ [, D! M/ t
case JOY_DOWN_D: /* 摇杆DOWN键按下 *// y" b/ I9 E# Y' F4 A
ucDataTravel = JOY_DOWN_D;; p2 S* j9 f- ^% x- u( m0 p, U. v
comSendChar(COM3, ucDataTravel);- X1 `& ~) _7 H
printf("摇杆下键按下\r\n");& S* V5 f, h6 D
break;
- X7 B# S/ Y! a+ D
3 i' R4 Z* O, [$ w( _* Z& B9 _
case JOY_DOWN_L: /* 摇杆LEFT键按下 */+ N1 O- F8 j7 G" O" R) ~" N
ucDataTravel = JOY_DOWN_L;! Y- V: F2 ?! x s8 q1 ^; A0 m
comSendChar(COM3, ucDataTravel);0 D6 e7 W B% v5 J5 E7 t
printf("摇杆左键按下\r\n");6 @ Z& K8 ~% P/ N( s/ o
break;! U3 w; a5 M$ P1 B% _- U+ n
% f7 t/ ^0 Y& u8 B
case JOY_DOWN_R: /* 摇杆RIGHT键按下 */* L9 j. s: O& w& [9 W( C& z! q, p
ucDataTravel = JOY_DOWN_R;
8 I) t; ~- x, b! r2 @* j
comSendChar(COM3, ucDataTravel);
# B9 A" q. g) r0 p
printf("摇杆右键按下\r\n");0 l! }- w) V3 ?# R; Y4 S
break;- O; m+ ^, }3 ?- k" @
- W- [4 T. S/ w7 e4 \- i
case JOY_DOWN_OK: /* 摇杆OK键按下 */# I) R6 p2 d7 u1 E0 J* u$ T
ucDataTravel = JOY_DOWN_OK;) T' M- Z1 t9 N# h
comSendChar(COM3, ucDataTravel);1 {1 j9 q. q0 @2 h2 ^
printf("摇杆OK键按下\r\n");& o8 Y8 j! @% F$ F
break;
( ?7 ]3 ^+ `' k- n& q# s/ d) { f
) d+ I% l- j6 l% g6 |" |4 W
case JOY_UP_OK: /* 摇杆OK键弹起 */
/ j4 {8 G# P# y" A0 r+ A0 _+ p
ucDataTravel = JOY_UP_OK;! f c) i( m i- ]4 y* U
comSendChar(COM3, ucDataTravel);
& K6 J6 n% e* M0 r
printf("摇杆OK键弹起\r\n");
4 B" L& J# B" `! Y0 M
break;
1 `0 y7 X ]" G) y. X$ m8 d0 _% E
. U! V Y& P( p* ], d6 S" [/ x
default:
4 p% O; R! \+ B3 O$ V2 h0 Q/ `( [
/* 其它的键值不处理 */
! h1 B& k: M: s5 A8 \2 T
break;6 \) t; ^# Z, N7 j3 C. K
}- A" L; V% o( Y2 O& X; M0 G5 V
}8 j. j! W3 c( {- l9 l7 u1 H+ R
}/ B' X6 v U) ]+ Z! E8 h9 c& Z
}

复制代码

31.10 总结
本章节就为大家讲解这么多，485通信依然在实际项目中非常实用。有线的串行网络仍然提供最有力、最可靠的通信，特别是在恶劣的环境中。

赞收藏评论0 发布时间：2021-10-27 11:12

0个回答

【经验分享】STM32H7的USART应用之RS485

所属标签