【经验分享】STM32H7的FDCAN总线应用之双FDCAN实现（支持经典CAN）

[复制链接]

STMCU小助手发布时间：2021-11-6 23:52

文章
文章封面:
文章简介:	本章节为大家讲解STM32H7的带两个FDCAN控制器使用方法。CAN FD中的FD含义就是flexible data，灵活数据通信，且波特率可以和仲裁阶段波特率不同。

92.1 初学者重要提示
1、  FDCAN相关知识点可以看第90和91章。

2、  CAN菊花链组网时，在两端接分别接120 Ω的终端电阻：链接地址。

3、  FDCAN控制器外接的PHY芯片输出的是差分信号，组网接线时，注意是CANL接CANL，CANH接CANH。

4、  经典CAN每帧最大8字节，FDCAN每帧最大64字节。

5、  CAN不接外置PHY芯片，通信测试方法：链接地址。

6、  关于CAN总线是否需要供地的问题：地址

7、  CAN组网只有一个节点的情况下，接示波器看不到FDCAN数据帧波形。

8、  特别推荐瑞萨的CAN入门中英文手册，做的非常好：链接地址

9、  带隔离功能的FDCAN芯片搜集：链接地址

10、  除了本章提供的基于ST HAL库实现的双FDCAN通信，再提供个基于CMSIS-Driver的：

基于STM32H7的CMSIS-Driver驱动实现双CAN FD和双经典CAN两种方式案例发布

92.2 FDCAN硬件接口设计
STM32H7带了两个FDCAN控制器，然后外接物理层PHY芯片就可以使用了。FDCAN1和FDCAN2外接芯片原理图如下：

使用的PHY芯片SN65HVD230即支持经典CAN，也支持FDCAN。PHY芯片输出的是差分信号，逻辑0或者逻辑1的电平效果如下：链接地址

92.3 FDCAN基础知识
FDCAN的基础知识在第90已经做了详细说，这里补充些本章要用到的知识点。

92.3.1 经典CAN和FDCAN的区别
CAN-FD的开发可以满足需要更高带宽的通信网络需求。每帧最多具有64个字节的CAN-FD以及将比特率提高到最大的可能性，使数据阶段要快8倍，在第二个仲裁阶段要恢复到正常的比特率。通过以下方式确保数据传输的完整性：

（1）17级多项式对最大16字节的有效载荷进行CRC。

（2）21级多项式对16到64字节之间的有效载荷进行校验。

标准帧和CAN FD的区别：

标识符后，CAN 2.0和CAN-FD具有不同的作用：

（1）CAN 2.0发送RTR位以精确确定帧类型：数据帧（RTR为主要）或远程帧（RTR）是隐性的）。

（2）由于CAN-FD仅支持数据帧，因此始终发送占优势的RRS（保留）。

IDE位保持在相同位置，并以相同的动作来区分基本格式（11位标识符）。请注意，在扩展格式的情况下，IDE位以显性或隐性方式传输（29位标识符）。

与CAN 2.0相比，在CAN-FD帧中，在控制字段中添加了三个新位：

（1）扩展数据长度（EDL）位：隐性表示帧为CAN-FD，否则该位为显性（称为R0）在CAN 2.0帧中。

（2）比特率切换（BRS）：指示是否启用两个比特率（例如，当数据阶段位以不同的比特率传输到仲裁阶段）。

（3）错误状态指示器（ESI）：指示节点处于错误活动模式还是错误被动模式。

控制字段的最后一部分是数据长度代码（DLC），它具有相同的位置和相同的长度（4位），用于CAN 2.0和CAN-FD。 DLC功能在CAN-FD和CAN 2.0中相同，但CAN-FD有很小变化（下表中的详细信息）。 CAN-FD扩展帧允许单个消息中发送64个数据字节，而CAN 2.0有效负载数据最多可以发送8个字节。

通过增加有效载荷数据的数据字段来改善网络带宽，因为需要更少的包处理。同时，通过为CRC添加更多位来增强消息完整性：

（1）如果有效载荷数据最多为16个字节，则CRC以17位编码。

（2）如果有效载荷数据大于20（16）个字节，则CRC以21位编码。

另外，为了确保CAN-FD帧的鲁棒性，填充位机制支持CRC字段。下表总结了CAN-FD和CAN 2.0之间的主要区别。提供的主要功能与CAN 2.0相比，CAN FD的改进之处在于数据有效负载的增加和速度的提高由CAN-FD中可用的BRS，EDL和ESI位来确保。

下表可帮助用户简化将STM32设备中的CAN 2.0协议升级到CAN-FD协议的过程。该表还指定了FDCAN的改进。与传统的BxCAN（基本扩展CAN）相比，FDCAN具有许多优势，包括更快的数据传输速度。速率和数据字节数的扩展，减少了帧开销。总线负载也可以减少。传输和接收中消息数量的增加要求RAM存储器的改进：

鉴于BxCAN的兼容性，BxCAN开发人员可以轻松地迁移到FDCAN，因为FDCAN可以无需对整个系统设计进行修订即可实施。 FDCAN包含所有BxCAN功能，并满足新应用程序的要求。

92.3.2 STM32H7的FDCAN1和FDCAN2的区别
仅FDCAN1支持TTCAN时间触发通信，而FDCAN2不支持。

92.3.3 FDCAN支持的最高速度
经典CAN是1Mbps，CAN FD最高2Mbps，CAN FD-SiC是5-8Mbps，CAN XL是10Mbps。

92.3.4 FDCAN的主时钟选择
FDCAN1和FDCAN2支持三种时钟源HSE，PLL1Q和PLL2Q，我们这里选择的PLL2Q输出20MHz。

92.3.5 FDCAN仲裁阶段和通信阶段波特率配置（重要）
CAN FD中的FD含义就是flexible data，灵活数据通信，且波特率可以和仲裁阶段波特率不同。看下面的图，意思就是红色部分可以是一个波特率，蓝色部分也可以是一个波特率。

波特率计算公式，看如下的位时间特性图：

1bit的CAN FD数据需要时间由Sync_Seg + Pro_Seg + Phase_Seg1 + Phase_Seg2组成。

仲裁阶段波特率对应的HAL库配置如下：

/* CAN时钟分配设置，一般设置为1即可，全部由PLL配置好，tq = NominalPrescaler x (1/ fdcan_ker_ck) */
9 y# @( r7 M" P5 R) s/ s
hfdcan2.Init.NominalPrescaler = 0x1; ! {( ]$ K4 Q E5 ?& q: _
0 t n+ K9 k/ ?: O5 r( |. Z6 C
/* 特别注意这里的Seg1，这里是两个参数之和，对应位时间特性图的 Pro_Seg + Phase_Seg1 */ # k' V% o3 H5 V* }8 ^7 Z5 i5 _
hfdcan2.Init.NominalTimeSeg1 = 0x1F; ; ?( m2 g3 ? ?# N
[ t( t* t4 Q( ]1 _6 U
/* 对应位时间特性图的 Phase_Seg2 */ ( M8 d4 Z( h/ Z
hfdcan2.Init.NominalTimeSeg2 = 0x8; 5 P; T( n& @. e+ o& r
) e8 g2 Q7 t6 X
/* 用于动态调节 Phase_Seg1和 Phase_Seg1，所以不可以比Phase_Seg1和 Phase_Seg1大 */7 c* i' X, x5 B1 O$ G# m% z
hfdcan2.Init.NominalSyncJumpWidth = 0x8;

复制代码

其中：

Sync_Seg是固定值 = 1 % J7 K- P! ?, ?: E3 w& Q6 i
Pro_Seg + Phase_Seg1 = DataTimeSeg1
* g) F: C Q( S( B0 i
hase_Seg2 = DataTimeSeg2

复制代码

FDCAN时钟是20MHz时，仲裁阶段的波特率就是

FDCAN Freq / (Sync_Seg + Pro_Seg + Phase_Seg1 + Phase_Seg2)

= 20MHz / （1+0x1F + 8）

= 0.5Mbps

数据阶段波特率对应的HAL库配置如下：

/* CAN时钟分配设置，一般设置为1即可，全部由PLL配置好，tq = NominalPrescaler x (1/ fdcan_ker_ck) */
% y( b8 x( v7 w+ K/ g; t* Y$ b
hfdcan2.Init.DataPrescaler = 0x1; - |1 Y n( {- B! H, c9 Q
( w" P" F* o+ @( `& |5 O) @
/* 特别注意这里的Seg1，这里是两个参数之和，对应位时间特性图的 Pro_Seg + Phase_Seg1 */
[+ b8 S% x6 M3 g% z$ p" A
hfdcan2.Init.DataTimeSeg1 = 0x5;
- R* [* }# P! J; v, a
1 T- [4 I6 [8 w
/* 对应位时间特性图的 Phase_Seg2 */2 o1 C' Y( ~: S- e% i4 `6 j d9 V
hfdcan2.Init.DataTimeSeg2 = 0x4; 3 v/ I' a& P, Y% c/ ]3 j
# Y& u, V7 {. I
/* 用于动态调节 Phase_Seg1和 Phase_Seg1，所以不可以比Phase_Seg1和 Phase_Seg1大 */
; y! t$ s* Y# {5 q4 t& F* |
hfdcan2.Init.DataSyncJumpWidth = 0x4;

复制代码

其中：

Sync_Seg是固定值 = 1
' x/ Q7 |* l7 g) l$ C7 R
Pro_Seg + Phase_Seg1 = DataTimeSeg1/ J# ~+ D; k: m2 _7 o s! O
hase_Seg2 = DataTimeSeg2

复制代码

FDCAN时钟是20MHz时，数据阶段的波特率就是

CAN FD Freq / (Sync_Seg + Pro_Seg + Phase_Seg1 + Phase_Seg2)

= 20MHz / （1+5+ 4）

= 2Mbps

STM32H7在400MHz情况下，PLL配置输出20MHz的CAN FD时钟（大家可以使用STM32CubeMX来配置的）：

/* 选择PLL2Q作为FDCANx时钟 */) U8 ?) d/ e- c5 I B/ m9 ?" A0 e
PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_FDCAN;
. p& E: b2 Y4 T1 p
PeriphClkInitStruct.PLL2.PLL2M = 5;2 q4 V6 m' j4 I
PeriphClkInitStruct.PLL2.PLL2N = 80;5 i4 Q& X, E2 p; A7 f3 L; h9 g
PeriphClkInitStruct.PLL2.PLL2P = 2;
+ c- J7 V ^5 b# |6 }
PeriphClkInitStruct.PLL2.PLL2Q = 20;) i- L" ?' b4 c: r) g/ U) { ^0 X* _0 A
PeriphClkInitStruct.PLL2.PLL2R = 2;* G3 ]/ s# P* j5 x2 T$ p! P0 n5 s
PeriphClkInitStruct.PLL2.PLL2RGE = RCC_PLL2VCIRANGE_2;+ S1 o, ]' G( o1 y- c
PeriphClkInitStruct.PLL2.PLL2VCOSEL = RCC_PLL2VCOWIDE;8 z; V" Y# D# n* D, L2 v" Z
PeriphClkInitStruct.PLL2.PLL2FRACN = 0;4 F0 g/ R, m s
PeriphClkInitStruct.FdcanClockSelection = RCC_FDCANCLKSOURCE_PLL2;5 L# ~$ Z. _5 [1 A/ e# o( L9 `
if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)* I; |+ W% \9 X! y6 A. ^: n8 m( U
{
3 y6 D& G6 A% C; d4 f
Error_Handler(__FILE__, __LINE__);9 _$ @- B" D1 P$ {' M4 k0 i- q/ l# c
}

复制代码

92.3.6 FDCAN的采样点位置推荐设置为85% - 90%
FDCAN每个bit的时间组成如下：

为了实现更好的稳定性，在满足指定波特率的情况下，让采样点的位置满足85%到90%是推荐的方式。主要用到HAL库的如下两个成员：

hfdcan2.Init.NominalTimeSeg1 6 R, V* a' [& q9 Y) d% P- _$ M
hfdcan2.Init.NominalTimeSeg2

复制代码

SyncSeg是固定1，也就是：

(SyncSeg + NominalTimeSeg1)/ (SyncSeg + NominalTimeSeg1 + NominalTimeSeg2)满足这个条件。

92.3.7 FDCAN的2560字RAM空间分配问题
关于FDCAN的2560字RAM空间在本教程第90章的第5小节有详细说明。本章配套程序将前1280字分配给FDCAN1，后1280字分配给FDCAN2。

92.3.8 FDCAN过滤器常用的范围过滤器和经典的位屏蔽过滤器
关于FDCAN的过滤器类型在本教程第90章的第6小节有详细说明，我们这里重点了解范围过滤器和经典位屏蔽过滤器。

范围过滤器
范围过滤器比较简单，也比较好理解，对应的HAL库配置代码如下：

sFilterConfig2.IdType = FDCAN_STANDARD_ID; - _) u" [3 u5 a! `, e8 j. ]- r
sFilterConfig2.FilterIndex = 0;
1 M5 C5 y$ d y
sFilterConfig2.FilterType = FDCAN_FILTER_RANGE;
+ N: r# z3 A9 p( s; b
sFilterConfig2.FilterConfig = FDCAN_FILTER_TO_RXFIFO0; / |3 y; R" @) H, {* { T
sFilterConfig2.FilterID1 = 0x111; ( E+ v$ [0 `. u5 V' p# b
sFilterConfig2.FilterID2 = 0x555; `$ p. G+ d4 Y/ K0 G
HAL_FDCAN_ConfigFilter(&hfdcan2, &sFilterConfig2);

复制代码

FilterType类型配置为FDCAN_FILTER_RANGE表示范围过滤器。

FilterID1 = 0x111和FilterID2 = 0x555表示仅接收 ≥0x111且 ≤ 0x555的ID。

经典的位屏蔽过滤
对应的HAL库配置代码如下：

sFilterConfig2.IdType = FDCAN_STANDARD_ID; 3 i5 ]5 }* ?" \/ R7 p$ Z
sFilterConfig2.FilterIndex = 0; $ P3 m( ]* D! r' ]1 C5 o+ b# \
sFilterConfig2.FilterType = FDCAN_FILTER_MASK; 3 H/ p9 ?! d: Y" A4 ?
sFilterConfig2.FilterConfig = FDCAN_FILTER_TO_RXFIFO0;
4 v5 x7 d! L! Z" J3 B" H
sFilterConfig2.FilterID1 = 0x222; * L f2 E U2 f$ n% q
sFilterConfig2.FilterID2 = 0x7FF; 9 g' A3 S2 b: j* S5 z" ]6 Y. {0 {
HAL_FDCAN_ConfigFilter(&hfdcan2, &sFilterConfig2);

复制代码

FilterType类型配置为FDCAN_FILTER_MASK表示经典的位屏蔽过滤。

FilterID1 = filter 表示ID。

FilterID2 = mask 表示ID屏蔽位，mask每个bit含义：

0: 表示FilterID1相应bit不关心，该位不用于比较。

1: 表示FilterID1相应bit必须匹配，即接收到的ID位必须与FilterID1的相应位一致。

我们这里FilterID1 = 0x222，FilterID2 = 0x7FF 表示仅接收ID为0x222的FDCAN帧。

92.4 FDCAN驱动代码实现
这里以FDCAN1为例进行说明，FDCAN2的驱动程序在本章配套例子里面也提供了。

92.4.1 FDCAN配置
代码里面对每个成员都进行了详细注释说明：

/*! d$ c1 }& Q- {
*********************************************************************************************************
% c3 Y2 Y- q a4 w7 w
* 函数名: bsp_InitCan1
2 P% e1 ?: o4 `; O0 r
* 功能说明: 初始CAN1
+ k6 ]) D4 g) j: I" G, x
* 形参: 无7 l/ V* X. y& ^; A% K% |' p
* 返回值: 无
9 e A; U& h V; L/ H
********************************************************************************************************* z- V& E4 f' t3 T
*/
* q' X+ S* ^( d1 y( n
void bsp_InitCan1(void) L, b8 |7 J" v$ a' t6 Q* j6 l0 K
{
5 B* k8 @7 `5 n q
/* 位时间特性配置
1 q- J. I, r) s: Z3 J3 z( F
Bit time parameter | Nominal | Data6 c0 t3 m b; \' ?
---------------------------|--------------|----------------) U" o- i* @5 f7 ^! `$ [5 V2 c
fdcan_ker_ck | 20 MHz | 20 MHz8 o; @2 M! D1 l8 f
Time_quantum (tq) | 50 ns | 50 ns1 {! k' j( Y4 c) ?" c; i
Synchronization_segment | 1 tq | 1 tq. D. g$ I6 S- t* Q, W, m& C
Propagation_segment | 23 tq | 1 tq+ i* m1 h$ W' U- V. m5 w& b) L
Phase_segment_1 | 8 tq | 4 tq6 J( G6 n: X8 ^# i' s x
Phase_segment_2 | 8 tq | 4 tq
0 A F \7 f( i4 u1 f" j' o
Synchronization_Jump_width | 8 tq | 4 tq
" Y$ @0 a1 V& N4 B1 w4 h7 y- ~7 [8 S
Bit_length | 40 tq = 2us | 10 tq = 0.5us* G2 i! s9 f- ?5 I' s
Bit_rate | 0.5 MBit/s | 2 MBit/s
) p6 Y+ W3 }2 P& M: v* J8 c
*/
7 K2 d" r1 H" D6 p
hfdcan1.Instance = FDCAN1; /* 配置FDCAN1 */ + W' N5 e5 u1 z
hfdcan1.Init.FrameFormat = FDCAN_FRAME_FD_BRS; /* 配置使用FDCAN可变波特率 */
r4 o! h. Y/ F: ?" I
hfdcan1.Init.Mode = FDCAN_MODE_NORMAL; /* 配置使用正常模式 */ 9 q3 }3 M; B. n9 W9 `& s
hfdcan1.Init.AutoRetransmission = ENABLE; /*使能自动重发 */ 2 T8 T" r& R& j) J/ o O( c; W
hfdcan1.Init.TransmitPause = DISABLE; /* 配置禁止传输暂停特性 */0 d8 f7 J" O4 E5 A1 V
hfdcan1.Init.ProtocolException = ENABLE; /* 协议异常处理使能 */
1 @5 ~; f Y( i; W+ u% c
j4 y7 J9 `/ E
/* 9 c) K/ u8 w$ Q% N9 L
配置仲裁阶段波特率
+ g' N9 B! `- E' ~2 W
CAN时钟20MHz时，仲裁阶段的波特率就是0 r9 {$ C" H3 [1 z+ @
CAN FD Freq / (Sync_Seg + Pro_Seg + Phase_Seg1 + Phase_Seg2) = 20MHz / （1+0x1F + 8） = 0.5Mbps ! Y) j/ E, e- y( ]& {. T1 Q
. D& h7 w. K9 k6 W4 g
其中Sync_Seg是固定值 = 1 ， Pro_Seg + Phase_Seg1 = NominalTimeSeg1， Phase_Seg2 = NominalTimeSeg2
. \5 q" S. ~& y( ~1 u6 r$ r
*/8 G# U) H. Z2 h
/* CAN时钟分配设置，一般设置为1即可，全部由PLL配置好，tq = NominalPrescaler x (1/ fdcan_ker_ck) */
6 p" j7 D+ b1 [( q6 S% g/ B
hfdcan1.Init.NominalPrescaler = 0x01; * Q, \8 b. L0 t" z m4 a ~8 X
/* 用于动态调节 Phase_Seg1和 Phase_Seg1，所以不可以比Phase_Seg1和 Phase_Seg1大 */
- {" ^/ g: \8 h! m8 s
hfdcan1.Init.NominalSyncJumpWidth = 0x08;
. z" W% G- Q. N6 l% N. f
/* 特别注意这里的Seg1，这里是两个参数之和，对应位时间特性图的 Pro_Seg + Phase_Seg1 */: |0 e% {$ `) o
hfdcan1.Init.NominalTimeSeg1 = 0x1F;
* @8 }% G4 u: m( j! x5 |
/* 对应位时间特性图的 Phase_Seg2 */
7 P, l/ X% Q# f# {
hfdcan1.Init.NominalTimeSeg2 = 0x08;
9 F3 s- c0 w: j. F! x
/* 3 `. H; E. j" N+ _1 s7 m
配置数据阶段波特率
* T/ e: p! @, r! w% Q0 v
CAN时钟20MHz时，数据阶段的波特率就是* Z# `7 z$ m, E7 w/ }+ N5 N6 l* q
CAN FD Freq / (Sync_Seg + Pro_Seg + Phase_Seg1 + Phase_Seg2) = 20MHz / （1+5+ 4） = 2Mbps8 d9 {5 \' y# o" W2 B3 x
0 @- E8 I9 w8 K2 `7 |, t) S
其中Sync_Seg是固定值 = 1 ， Pro_Seg + Phase_Seg1 = DataTimeSeg1， Phase_Seg2 = DataTimeSeg2
) x& T7 o' @, L3 Z
*/
5 c2 j# x; O/ a# }9 O, C
/* CAN时钟分配设置，一般设置为1即可，全部由PLL配置好，tq = NominalPrescaler x (1/ fdcan_ker_ck)，9 _3 v6 e8 C$ N. t t& }3 ]
范围1-32 */
+ S8 K5 ?/ v8 | I1 b4 F
hfdcan1.Init.DataPrescaler = 0x01;
" U' q9 k5 [% Q( n& F2 o0 `+ L
/* 用于动态调节 Phase_Seg1和 Phase_Seg1，所以不可以比Phase_Seg1和 Phase_Seg1大，范围1-16 */: z5 |5 `/ |6 j2 N* w. @: T( ]) D
hfdcan1.Init.DataSyncJumpWidth = 0x04; * P; t) y9 X' W7 X/ X2 L# r; B
/* 特别注意这里的Seg1，这里是两个参数之和，对应位时间特性图的 Pro_Seg + Phase_Seg1，范围 */
; J1 L. @( |4 ^1 s
hfdcan1.Init.DataTimeSeg1 = 0x05; - Q3 ]! C* Y+ ~5 a
/* 对应位时间特性图的 Phase_Seg2 */ m* l( g2 Y8 N+ f9 x( Y" i" y" p
hfdcan1.Init.DataTimeSeg2 = 0x04; / b& ~ g' _8 J/ P- g# Z4 I
0 t5 X# ^( }2 ~4 F
' r6 l) j. T* f) p6 D. o0 C: j! Z
hfdcan1.Init.MessageRAMOffset = 0; /* CAN1和CAN2共享2560个字, 这里CAN1分配前1280字 */
a: D# ^( u' I+ ~
* D) q' O: R5 C9 d- ?3 c! Z
- f& u, |9 A* w# E
hfdcan1.Init.StdFiltersNbr = 1; /* 设置标准ID过滤器个数，范围0-128 */ ! U& j1 i0 S3 v' Y$ L
hfdcan1.Init.ExtFiltersNbr = 0; /* 设置扩展ID过滤器个数，范围0-64 */
+ ~5 b( D& v9 ?# o+ R) x
hfdcan1.Init.RxFifo0ElmtsNbr = 2; /* 设置Rx FIFO0的元素个数，范围0-64 */
! F% x# Y5 @1 i& J
/* 设置Rx FIFO0中每个元素大小，支持8,12,16,20,24,32,48或者64字节 */ % Q5 p( S/ t8 |( d
hfdcan1.Init.RxFifo0ElmtSize = FDCAN_DATA_BYTES_8; : s1 `+ W/ P: l$ _6 m
hfdcan1.Init.RxFifo1ElmtsNbr = 0; /* 设置Rx FIFO1的元素个数，范围0-64 */
1 A8 c; V( M( d8 Z) A
/* 设置Rx FIFO1中每个元素大小，支持8,12,16,20,24,32,48或者64字节 */ P1 A+ B5 y# Q. M( [3 ~
hfdcan1.Init.RxFifo1ElmtSize = FDCAN_DATA_BYTES_8; 0 f% S0 e5 d) m. Y
hfdcan1.Init.RxBuffersNbr = 0; /* 设置Rx Buffer个数，范围0-64 */3 L: J; e6 {' B( s& u
t7 x: U6 C1 ^0 U+ P. I
/* 设置Rx Buffer中每个元素大小，支持8,12,16,20,24,32,48或者64字节 */3 `! }" }+ ^6 j8 g* w
hfdcan1.Init.RxBufferSize = 0;
, A( j4 x. R4 Q& V4 T
hfdcan1.Init.TxEventsNbr = 0; /* 设置Tx Event FIFO中元素个数，范围0-32 */ 9 L, V5 t/ @, {4 H3 U
hfdcan1.Init.TxBuffersNbr = 0; /* 设置Tx Buffer中元素个数，范围0-32 */# c; g) [' s$ n( i/ H
hfdcan1.Init.TxFifoQueueElmtsNbr = 2; /* 设置用于Tx FIFO/Queue的Tx Buffers个数。范围0到32 */5 L: i4 z, B# s! N% y
hfdcan1.Init.TxFifoQueueMode = FDCAN_TX_FIFO_OPERATION; /* 设置FIFO模式或者QUEUE队列模式 */
# ? `, }$ P- R$ N
/* 设置Tx Element中的数据域大小，支持8,12,16,20,24,32,48或者64字节 */5 _: [/ N; A# f, k3 i
hfdcan1.Init.TxElmtSize = FDCAN_DATA_BYTES_8;
- n% g+ p7 ~" k8 i
HAL_FDCAN_Init(&hfdcan1);( h# ^6 E0 |. O$ z3 I
/* 7 T( ~. g- A0 I9 G8 b) M8 g
配置过滤器, 过滤器主要用于接收，这里采样屏蔽位模式。1 E; j) I& a* j% Z4 ^4 ]8 |: T
FilterID1 = filter
% o" x; [+ [- @
FilterID2 = mask1 u% N) t& y$ ]
+ K k: J; l% S" A4 Z8 d' u- i4 j0 C
FilterID2的mask每个bit含义
8 f/ \3 h( [: K/ c& I) D, c, ?/ U) \
0: 不关心，该位不用于比较；
4 z" R( G7 F: ^6 J" b* X4 h: s, P
1: 必须匹配，接收到的ID必须与滤波器对应的ID位相一致。3 n( w9 x+ w8 s: F. I6 |
# M9 p: F8 \! d: P4 `( g
举例说明：
1 ~) x4 W0 \; t! Y& s+ q
FilterID1 = 0x111
$ j l$ w7 G- Z1 f" s' v8 |. y* H
FilterID2 = 0x7FF
4 f/ d- z# |! ` L2 d
表示仅接收ID为0x111的FDCAN帧。0 w! O: l- M6 e) H1 P" _7 H% ]- d
. u; ]% W8 t9 ?! O2 x8 b+ h
*/
# [- ~; @1 u7 y2 k" X8 u
sFilterConfig1.IdType = FDCAN_STANDARD_ID; /* 设置标准ID或者扩展ID */
: B! A1 E1 n# k
/* 用于过滤索引，如果是标准ID，范围0到127。如果是扩展ID，范围0到64 */% C+ ]" H; y/ M! {7 z9 D
sFilterConfig1.FilterIndex = 0;
2 W8 o; g) ?% v/ Z+ o
sFilterConfig1.FilterType = FDCAN_FILTER_MASK; /* 过滤器采样屏蔽位模式 */
% q1 S( E1 H. C8 q8 O
sFilterConfig1.FilterConfig = FDCAN_FILTER_TO_RXFIFO0; /* 如果过滤匹配，将数据保存到Rx FIFO 0 */; n+ w) O; ~8 z8 p& B
sFilterConfig1.FilterID1 = 0x111; /* 屏蔽位模式下，FilterID1是消息ID */6 S8 J& F' u: `1 y/ u8 G0 n
sFilterConfig1.FilterID2 = 0x7FF; /* 屏蔽位模式下，FilterID2是消息屏蔽位 */
2 t3 r5 n) f {
HAL_FDCAN_ConfigFilter(&hfdcan1, &sFilterConfig1); /* 配置过滤器 */% o- N1 [$ K9 o' o
: R; T9 U- b+ k4 p7 b8 C
/* 设置Rx FIFO0的wartermark为1 */$ B) K% M6 e4 A4 W! V* \
HAL_FDCAN_ConfigFifoWatermark(&hfdcan1, FDCAN_CFG_RX_FIFO0, 1);
/* 激活RX FIFO0的watermark通知中断，位开启Tx Buffer中断*/
1 D$ n6 `& T+ |
HAL_FDCAN_ActivateNotification(&hfdcan1, FDCAN_IT_RX_FIFO0_WATERMARK, 0);
, K; T8 \+ @, ^' ?1 Z. ]2 l1 F/ ~
/* 启动FDCAN */
) N0 y9 s5 X8 I' H E2 i
HAL_FDCAN_Start(&hfdcan1); 1 [! T4 G# J" ^# a' f
}

复制代码

92.4.2 FDCAN的GPIO，NVIC等配置
主要配置了FDCAN的GPIO，GPIO时钟，FDCAN时钟和NVIC：

/*# r4 p4 K4 @8 s& O+ G6 V1 z
*********************************************************************************************************4 N* t" e$ E3 Q$ ^
* 函数名: HAL_FDCAN_MspInit
; f' S# K4 Q5 F, {# h }
* 功能说明: 配置CAN gpio) F4 J3 h! j: H# A/ B. T
* 形参: hfdcan
, G2 y/ c, w$ W, O/ J0 m: x
* 返回值: 无
, g( t/ R$ V6 k9 i
********************************************************************************************************* i2 _8 o$ ~/ O$ f8 A. ~
*/
% ^# _3 Y' {( X7 e
void HAL_FDCAN_MspInit(FDCAN_HandleTypeDef* hfdcan)' e$ n$ W3 Z4 S* e5 S3 v5 X
{8 k; P/ k5 k5 d) v
GPIO_InitTypeDef GPIO_InitStruct;
- [+ V; I% f) N
RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};
6 a% T% S2 F6 y5 ?/ T) c0 ^
. S2 g" e6 s0 n( m% I6 G- M
if (hfdcan == &hfdcan1)
. k6 t$ i6 U/ A0 K/ w1 @
{
+ f5 R. O4 h( T7 r/ T
/*##-1- 使能外设这个GPIO时钟 #################################*/
" S7 v! p H% o# ^5 h
FDCAN1_TX_GPIO_CLK_ENABLE();( S4 I. k4 R# V) R& f! \- u1 \
FDCAN1_RX_GPIO_CLK_ENABLE();, _5 m1 ~, v1 [! e7 f8 ]/ d
3 U4 s8 L* y4 [& i. X) p
/* 选择PLL2Q作为FDCANx时钟 */5 { @; y/ _3 U O0 I# p
PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_FDCAN;
0 {4 G6 @; q4 ^% ]9 K9 |
PeriphClkInitStruct.PLL2.PLL2M = 5;
. H; d0 Y& t1 H4 D6 l% M6 O2 R! V9 t
PeriphClkInitStruct.PLL2.PLL2N = 80;# V' p4 l* }. S) e$ f% [: p" X6 ~
PeriphClkInitStruct.PLL2.PLL2P = 2;
) C% v( ~; ~% {/ |1 _
PeriphClkInitStruct.PLL2.PLL2Q = 20;
. C. @9 E, d( J. N- A" f. \4 V
PeriphClkInitStruct.PLL2.PLL2R = 2;+ |5 {9 }, N6 U" D6 G
PeriphClkInitStruct.PLL2.PLL2RGE = RCC_PLL2VCIRANGE_2;
( s- {3 j9 q# E( {2 {& ] X
PeriphClkInitStruct.PLL2.PLL2VCOSEL = RCC_PLL2VCOWIDE;
V. B/ U: T/ i: y& i5 T7 @2 `8 K
PeriphClkInitStruct.PLL2.PLL2FRACN = 0;) L9 Y* K9 s7 h! K8 a8 d+ k
PeriphClkInitStruct.FdcanClockSelection = RCC_FDCANCLKSOURCE_PLL2;" l1 @. N& O; s8 R/ N' b
if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK) O7 X& a- ]* H- b$ }5 }
{
7 c9 w5 N" e6 Q/ o% a
Error_Handler(__FILE__, __LINE__);, O1 H: D5 |* H, R. {2 V" B
}
4 v; G0 c6 P& Y3 j' v
6 e7 a/ E9 ?7 l+ z. L6 F8 E
__HAL_RCC_FDCAN_CLK_ENABLE();+ I5 j3 }- H8 X" p% j7 J0 k
2 B7 M/ Z" A5 [! A8 |* w
GPIO_InitStruct.Pin = FDCAN1_TX_PIN;" R0 F) h) ]4 G G# w/ h/ a! D1 V
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
/ B5 L7 X" T- J9 T4 T9 r; d |
GPIO_InitStruct.Pull = GPIO_PULLUP;% X7 V. {$ Q* Y: L {* T
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
% D- ~3 h$ Q1 n2 S |% _
GPIO_InitStruct.Alternate = FDCAN1_TX_AF;: [# |6 V1 Z) ]( F
HAL_GPIO_Init(FDCAN1_TX_GPIO_PORT, &GPIO_InitStruct);
) H0 G1 `+ V! `
! m7 a( M) `) Z
GPIO_InitStruct.Pin = FDCAN1_RX_PIN;
% y( r t9 g4 z' j
GPIO_InitStruct.Alternate = FDCAN1_RX_AF;* f! |9 A- A2 G( I
HAL_GPIO_Init(FDCAN1_RX_GPIO_PORT, &GPIO_InitStruct);
5 y: ~0 H) W$ A7 E* V$ t
8 q f( k( j5 d5 h! ]- l
HAL_NVIC_SetPriority(FDCAN1_IT0_IRQn, 2, 0);
) a9 c' s' i, C- q
HAL_NVIC_SetPriority(FDCAN1_IT1_IRQn, 2, 0);4 L7 g& h; s1 P* H% T( a! ?, u6 W4 W
HAL_NVIC_SetPriority(FDCAN_CAL_IRQn, 2, 0);
1 b) p! ~* H; c/ Y
HAL_NVIC_EnableIRQ(FDCAN1_IT0_IRQn);
" ]) t" B+ L; v; M3 E l
HAL_NVIC_EnableIRQ(FDCAN1_IT1_IRQn);
5 u6 i9 T- ~0 [' Y) X7 Y) n/ ?
HAL_NVIC_EnableIRQ(FDCAN_CAL_IRQn);
0 u8 y! f2 E9 O, |
}
- i. y' z. S9 c" M9 z
}

复制代码

92.4.3 FDCAN的数据发送
FDCAN每帧数据最大64字节：

/*! S5 L8 I l1 w+ q3 @ B, B
*********************************************************************************************************
, |) D6 Y4 A9 h' w9 _ }$ I# P
* 函数名: can1_SendPacket
0 R. y% z4 r9 a, f
* 功能说明: 发送一包数据, D5 w! w/ g: H7 G. y& }
* 形参：_DataBuf 数据缓冲区
$ K, u8 I! l1 o' b% [: Y( j1 Y
* _Len 数据长度, 支持8,12,16,20,24,32,48或者64字节
5 `3 G/ }% o+ A2 n: l9 H
* 返回值: 无; X1 V6 X9 ]) a: ]$ X. l! e
*********************************************************************************************************
) y5 R5 p$ A+ v2 i4 d: `# E
*/
" i9 D' M# ^1 R( F/ @/ d# F: l
void can1_SendPacket(uint8_t *_DataBuf, uint8_t _Len)" f m! A* W' b: E# Z4 J5 {) E
{
9 j' \4 ?' ~' B6 }5 P! v) P# I
FDCAN_TxHeaderTypeDef TxHeader = {0};
' y1 s3 j8 l" S O2 b; ~9 u' ?
, X9 A: g; r' ?- K3 [# v: A
/* 配置发送参数 */
+ A. w) k) o6 p2 h" J
TxHeader.Identifier = 0x222; /* 设置接收帧消息的ID */
- D4 g: q: m- c0 \* D2 o g
TxHeader.IdType = FDCAN_STANDARD_ID; /* 标准ID */
0 T' ]" z! k( I1 [- j
TxHeader.TxFrameType = FDCAN_DATA_FRAME; /* 数据帧 */7 j1 ]3 Z; _$ y6 u, s6 `3 V z6 Y; s
TxHeader.DataLength = (uint32_t)_Len << 16; /* 发送数据长度 */
4 p4 A a# V! Q4 F! d+ V5 u7 v
TxHeader.ErrorStateIndicator = FDCAN_ESI_ACTIVE; /* 设置错误状态指示 */+ r, r' a1 r/ P8 B( j
TxHeader.BitRateSwitch = FDCAN_BRS_ON; /* 开启可变波特率 */
3 ` L0 ~& R' a2 V7 b* S
TxHeader.FDFormat = FDCAN_FD_CAN; /* FDCAN格式 */
1 \4 {! W" V" g8 I; L. k5 w
TxHeader.TxEventFifoControl = FDCAN_NO_TX_EVENTS;/* 用于发送事件FIFO控制, 不存储 */
. ~. L9 c( X1 Q4 l& _8 J1 I2 l
TxHeader.MessageMarker = 0; /* 用于复制到TX EVENT FIFO的消息Maker来识别消息状态，范围0到0xFF */
5 k: t' i& w' r
- m2 u/ ]8 p7 Z- P$ f9 n
/* 添加数据到TX FIFO */
5 }+ j) h6 Q( g) A3 y! r
HAL_FDCAN_AddMessageToTxFifoQ(&hfdcan1, &TxHeader, _DataBuf);, S6 \ s3 X2 w# c
}

复制代码

这里特别注意两点：

发送的数据幅值给DataLength，需要右移16bit。
要发送的数据会被复制到TX FIFO硬件缓存中。
92.4.4 FDCAN的中断服务程序处理
这里FDCAN中断主要用于数据接收：

/*
6 {! k- K! Q9 K2 {7 K D( M5 q5 D
*********************************************************************************************************
: i; Z* E; H3 v: b" X" ^, d2 E( W
* 函数名: FDCAN1_IT0_IRQHandler
- M. m0 H* s- N( x9 T
* 功能说明: CAN中断服务程序+ ~( {% B+ y( {& M! i _1 e1 l
* 形参: hfdcan
" m: a [ O! m& K. _' J
* 返回值: 无
4 b0 f; c& G- Y% D, _ A2 K$ ^" p
*********************************************************************************************************
& }$ D; A7 ~% W
*/; J1 G* P' [) g# W; c8 {
void FDCAN1_IT0_IRQHandler(void)1 v8 \6 Z/ A' q4 z0 X+ I0 A! k
{
: j" ^% E( [1 Z' P+ |- O
HAL_FDCAN_IRQHandler(&hfdcan1);
, s$ U5 p$ _# R: q, B: l, h4 |
}; ~9 B2 D/ B t" z. h
/ l- _+ Z% l$ `! Q F
void FDCAN1_IT1_IRQHandler(void)2 p$ N# q: I! ?) g6 L! x" ?* x- n
{
* Z+ K! b& J" }
HAL_FDCAN_IRQHandler(&hfdcan1);
* R* J% ~* i$ h
}
" q8 d) y- I, ^* u
( ]' p! t& r) G. e+ O* _; }
void FDCAN_CAL_IRQHandler(void)
6 N1 f# d! M; K) a: {$ [' n/ a3 C7 s
{
, H6 u, T9 c$ G) k5 n% n4 J3 [. v/ w
HAL_FDCAN_IRQHandler(&hfdcan1);: ]. w/ w0 W( ^$ \1 E) h
}6 e8 H& ^' i' j9 z: o8 ~2 \
/*
* t- K2 [' a& F7 H
*********************************************************************************************************
- d: J0 K- e+ ^8 V2 e) ]: x
* 函数名: HAL_FDCAN_RxFifo0Callback
3 l0 b* V+ _% t4 `
* 功能说明: CAN中断服务程序-回调函数4 _" u2 Q' r2 g" N. o
* 形参: hfdcan
& E# Z4 H3 K0 a" S
* 返回值: 无9 n6 f; N( n) b( d7 Q! B; ?. U. H, d
*********************************************************************************************************
8 Q% h5 f" Q9 v' R! B7 `9 A
*/
" D, X: A5 ?$ G5 O7 a
void HAL_FDCAN_RxFifo0Callback(FDCAN_HandleTypeDef *hfdcan, uint32_t RxFifo0ITs)* o6 w! r9 T! k
{
9 {# f. `, N& |! Y- `
if (hfdcan == &hfdcan1)( R% Y0 ^9 N4 J7 j! g
{
$ \6 Z) v* u/ I b9 q, e8 l
if ((RxFifo0ITs & FDCAN_IT_RX_FIFO0_WATERMARK) != RESET)9 G) Y; e P; M3 B }( Q
{
5 S9 G3 _/ Z' o# _$ ^5 k
/* 从RX FIFO0读取数据 */1 y6 r& y. o) h [
HAL_FDCAN_GetRxMessage(hfdcan, FDCAN_RX_FIFO0, &g_Can1RxHeader, g_Can1RxData);
6 i: q- k( F7 _9 C$ l$ O" j" T2 n" W
' j- w' o6 X& U; O) B
/* 激活Rx FIFO0 watermark notification */) @# @6 J, L- B
HAL_FDCAN_ActivateNotification(hfdcan, FDCAN_IT_RX_FIFO0_WATERMARK, 0);
% I5 s8 {0 u" ~& r; t5 s. @
3 B& T5 ~7 v- D" J) p
if (g_Can1RxHeader.Identifier == 0x111 && g_Can1RxHeader.IdType == FDCAN_STANDARD_ID)
2 k# @4 E5 m8 `. N
{0 s. K( r& o& d! y" ^: w! N
bsp_PutMsg(MSG_CAN1_RX, 0); /* 发消息收到数据包，结果在g_Can1RxHeader， g_Can1RxData */
5 a% c6 H. u3 k- T' s# |! ?/ d
}3 t, j5 \- w5 q
}( h9 Y6 w# Z: G& b3 U. E6 r* t
}& W9 [) r# f9 D- E
}

复制代码

92.5 双FDCAN测试的接线和跳线帽说明
大家可以直接使用板载的两个FDCAN进行通信测试。跳线帽设置如下：

双CAN FD接线：

92.6 开发板和H7-TOOL的FDCAN助手测试
H7-TOOL的CAN/CANFD助手支持以太网，USB和WiFi三种通信方式。大家可以用使用本章配套的双FDCAN例子与H7-TOOL的FDCAN助手进行通信。

92.6.1 接线说明
H7-TOOL和STM32H7的FDCAN2进行通信，注意是CANH接CANH, CANL接CANL

92.6.2 启动H7-TOOL上位机
打开最新版的H7-TOOL上位机，使用USB，以太网或者WiFi方式均支持。选择左侧的CAN助手 -> 启动CAN助手：

参数介绍：

（1）帧类型：0 - 经典CAN，最大收发8字节

1 - CAN FD , 仲裁段和数据点波特率相同，最大收发64字节

2 - CAN FD 双波特率，仲裁段和数据点波特率不同，最大收发64字节

（2）仲裁段和数据段波特率：除了提供常用的波特率，还提供了用户可自定义配置模式，需要用户选择如下选项，这样就可以配置右侧的“CAN波特率高级配置”

我们这里选择CAN FD双波特率，仲裁段设置为500Kbps，数据段设置为2Mbps，最大数据设置为8字节， CAN解码器设置为none_decoder.lua

92.6.3 H7-TOOL的FDCAN接收数据测试
第2步设置完毕参数后，按下几次STM32H7板子的 K1，可以看到H7-TOOL上位机接收到了数据：

92.6.4 H7-TOOL的FDCAN发送数据测试
如果有多种发送格式，用户可以在快捷面板里面发送，这个面板也支持用户加载专门的配置文件，不用每次都设置。

如下的配置，点击发送，可以控制STM32H7板子的LED1点亮：

如下的配置，点击发送，可以控制STM32H7板子的LED1熄灭：

92.7 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

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

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

第1步，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器，LED和串口。
第2步，FDCAN应用程序设计部分。
92.8 实验例程说明（MDK）
配套例子：

V7-069_双CAN FD之间通信

实验目的：

学习双CAN FD的实现。
实验内容：

K1按键按下，CAN2发送消息给CAN1，蜂鸣器鸣响4次。
K2按键按下，CAN1发送消息给CAN2，点亮LED1。
K2按键按下，CAN1发送消息给CAN2，熄灭LED1。
注意事项：

接线方式是CAN1的CANL1和CAN2的CANL2连接，CAN1的CANH2和CAN2的CANH2连接，具体接线看本工程Doc文件中的截图。
启用CAN1，需要将V7主板上的J12跳线帽短接PA11，J13跳线帽短接PA12。
启用CNA2，硬件无需跳线，要禁止使用以太网功能（有引脚复用）。

上电后串口打印的信息：

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

程序设计：

系统栈大小分配：

RAM空间用的AXI SRAM：

硬件外设初始化

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

/*3 G# ?/ `0 n0 ~8 }7 }% Y9 V
*********************************************************************************************************
" b5 u' Z% D" s6 q
* 函数名: bsp_Init
Q* |( t$ O% M& K7 X8 Y' h9 }6 g
* 功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
& K9 t& F7 J- X2 s: w9 C+ Q) k
* 形参：无, o' h9 L1 c9 {2 Q6 M/ D W, W" _
* 返回值: 无
9 I2 Z7 ]- R( L8 e3 {" P9 q
*********************************************************************************************************( j& |2 R$ V C! {$ L o# l
*/9 i" N0 E8 w* A9 k
void bsp_Init(void)
# P5 [( b4 b+ w2 E
{3 `% b4 z4 A Q9 p) c
/* 配置MPU */
- d5 i8 h4 r0 U( c- L
MPU_Config();; }9 X: [2 a9 H! [4 v2 q" x" |
# H' |: J5 J1 e
/* 使能L1 Cache */0 ?, I( A$ c1 G6 r8 j6 E
CPU_CACHE_Enable();
+ ]# y$ S& d5 C4 d
; e$ l) i' ^, w$ W' g' J
/*
9 \ e1 |; |: }$ o8 f
STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:- O; O9 h1 G+ W/ {, r1 U. W
- 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
; \1 q$ h/ P; u9 t) ?& X- ]4 {
- 设置NVIV优先级分组为4。
: X4 ^* `- _* D, c+ c
*/$ z) A0 k1 ~4 r
HAL_Init();8 C7 {& R: H* Z1 i: E6 W
6 f/ ~( O+ h3 O
/* D& T) W" K, l& H0 I% i6 l6 C
配置系统时钟到400MHz% }: o; f* y. O: P
- 切换使用HSE。
; B u7 M' p1 I
- 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
; N% E4 W9 f( y- F
*/1 d& d8 ]" q# W6 e1 Y
SystemClock_Config();
: A5 N1 ]1 J o9 w4 `
% G6 k8 t) ]" w' g
/*
: X ]! {& W. N& [: w% Y5 G
Event Recorder：
( y6 D& @$ g J8 F5 H& [ k
- 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
) H, y, A |, M* m
- 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章% L, ?! R9 U R5 s- R1 M. e6 s A
*/ . p6 q; L$ E* h( Z6 C0 K
#if Enable_EventRecorder == 1
0 K [) ?' n- k% X' `
/* 初始化EventRecorder并开启 */
3 }5 k) p! N5 l& c8 Q
EventRecorderInitialize(EventRecordAll, 1U);* I @2 ]8 X8 |; ]
EventRecorderStart();
4 K! `; |( t8 ^2 ^/ K+ S& b- P
#endif
/ a$ M; Y, B0 ]" y
( v$ s. I7 f+ q9 }# M, A
bsp_InitKey(); /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */; B7 f( P5 k' b6 Q+ G
bsp_InitTimer(); /* 初始化滴答定时器 */
- S. f; M1 R$ \4 j( A8 H ?/ j: v
bsp_InitUart(); /* 初始化串口 */* y" D2 A$ b8 E, L" v) w. i
bsp_InitExtIO(); /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */
2 m# q4 P( e \5 g" E$ S
bsp_InitLed(); /* 初始化LED */
- H# Y1 F/ K7 L: m: f
}

复制代码

MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区和FMC的扩展IO区。

/*2 D2 N G& s) l7 C [/ ]2 Z3 C
*********************************************************************************************************
: K- L" H: Q4 W9 u s
* 函数名: MPU_Config
) t H+ H3 f' T' d. n
* 功能说明: 配置MPU
/ r# e) V, y* G$ a9 z' @3 h
* 形参: 无
) _# p0 z. [0 u! l
* 返回值: 无$ l# L. M$ j j: p* ]; f8 k
*********************************************************************************************************
% V$ `8 ?; B, A
*/
* Y9 Q9 A/ M5 ^. Z- Z* }) o
static void MPU_Config( void )
% {+ f' l( o# v
{
* Y0 u* _2 s6 Z1 c
MPU_Region_InitTypeDef MPU_InitStruct;
2 [! x- F# j) B8 `6 r
4 O ?. e" g# D3 a
/* 禁止 MPU */
" b" Y* K) e# c1 Q* ~3 }
HAL_MPU_Disable();
3 g- j1 q5 N; c- Y+ m" q
7 ^1 i+ k3 d. G2 x( C
#if 0
" J# ]* w% s; y. R# `
/* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
: _1 C/ t" ~5 z8 t, a- Y
MPU_InitStruct.Enable = MPU_REGION_ENABLE;; G; C6 X- W7 h# l- C
MPU_InitStruct.BaseAddress = 0x24000000;
& S7 A. c* Q! i1 E
MPU_InitStruct.Size = MPU_REGION_SIZE_512KB;9 R& w, {0 K! e3 h; \* l. t
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
' [ h: H3 @; r# l
MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE;7 T8 e; z: l) P$ }0 H5 o9 J1 F
MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;
( W0 v" M. o; v& K$ t& w
MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
" T1 `! b0 W S; ~9 J6 V
MPU_InitStruct.Number = MPU_REGION_NUMBER0;$ I2 t* z$ o2 V4 R) l! b
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL1;
! x& w( G) s& J' H" d
MPU_InitStruct.SubRegionDisable = 0x00;
8 `9 E$ J& V7 t6 F$ z O9 X
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;! d* b8 m$ U( d/ t1 C
3 S( w+ j$ I1 \5 g5 E1 e
HAL_MPU_ConfigRegion(&MPU_InitStruct);
! ~& } m: F( k2 t: H
/ ?! V' m5 @9 k! m
#else$ Y9 d" u! \9 l7 f& Q
/* 当前是采用下面的配置 */) j1 r+ t5 S. i
/* 配置AXI SRAM的MPU属性为NORMAL, NO Read allocate，NO Write allocate */
' e, ^3 X7 q; W: v$ U
MPU_InitStruct.Enable = MPU_REGION_ENABLE;3 U$ A. o/ b$ g0 v
MPU_InitStruct.BaseAddress = 0x24000000;6 ~0 w; {, o: y. P! O A7 J
MPU_InitStruct.Size = MPU_REGION_SIZE_512KB;
! g: \, B; _' Q) M$ P
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
! e+ Q8 r0 O- w0 `
MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;: ]$ a! N+ v: ]
MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE;
7 o* h/ Q2 y/ \. O. L" ?
MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
% B- u( F8 @% D$ V
MPU_InitStruct.Number = MPU_REGION_NUMBER0;) N- C6 c1 O. L5 B5 E$ N' G) s
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL1;+ }5 ?1 p/ A* D$ X1 y) _
MPU_InitStruct.SubRegionDisable = 0x00;% l) W& W8 r0 [1 Y
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;0 t: Q2 A" e( b
3 g6 E! x+ t: l- i4 i
HAL_MPU_ConfigRegion(&MPU_InitStruct);) n* {8 F1 N7 [/ ?$ J" t' I) {
#endif; E, J9 \! v0 g! |) b$ p5 U" M
/* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */2 ^* [) h9 x$ i+ e" `6 w$ N
MPU_InitStruct.Enable = MPU_REGION_ENABLE;
# k8 U5 f! {2 R
MPU_InitStruct.BaseAddress = 0x60000000;
) L+ l0 Y/ c9 _* Y* X
MPU_InitStruct.Size = ARM_MPU_REGION_SIZE_64KB; . ^, C/ p6 ^- }
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
! y" g# [) [, T8 e1 F/ u1 ~
MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE;1 U6 y/ j( m% }/ t' G
MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE;! ]" l6 ~8 C( X! F! P& {6 P* g5 k
MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;( ~% R4 k- }% Q
MPU_InitStruct.Number = MPU_REGION_NUMBER1;
' `7 k# v" M) a; ]" a# }
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;1 L% O6 o/ _8 z6 _, P6 x! T
MPU_InitStruct.SubRegionDisable = 0x00;, {, G P+ f. K+ @+ Z: h2 k; S. O
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;
; C/ N# ?; N V( M: Q" t
; C6 M* F% Y4 ^$ x! Y: D
HAL_MPU_ConfigRegion(&MPU_InitStruct);
" V3 J; E% H4 M% V
3 o8 }" H5 b4 q
/*使能 MPU */$ v6 o/ g8 M( n1 s
HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);7 `' b) c* O! j: f5 q$ c
}
; E+ @4 V# U* r# _/ o& s7 o* o
# F8 k% s; {7 \1 g
/*8 G# F+ f" Z8 J$ X
*********************************************************************************************************
i4 X, i, h# }: x8 f) v& M
* 函数名: CPU_CACHE_Enable3 G3 |8 C9 d8 ~5 A' C5 e
* 功能说明: 使能L1 Cache+ u# v: c; E. c+ q2 f! T: }6 _
* 形参: 无, D0 {: O- S, f
* 返回值: 无
6 Y- h, |0 D6 M
*********************************************************************************************************6 V: F4 ^) I* q: \# a2 C
*/6 }+ p/ \) E5 A' P$ U5 Q
static void CPU_CACHE_Enable(void)- p# j j8 I0 |- a6 o4 m
{& ~' z* j* w8 O5 C3 c4 i
/* 使能 I-Cache */
2 l+ h2 ?4 u; H3 {& }& w
SCB_EnableICache();, B9 c3 z" P2 T) b$ J4 C8 R
& P' t% i. J/ e% e; G) Y8 D z
/* 使能 D-Cache */# I. U/ z6 P) P
SCB_EnableDCache();
, ?' A3 G5 j0 @! p4 }% t
}

复制代码

  主功能：

主程序实现如下操作：

  上电启动了一个软件定时器，每100ms翻转一次LED2。
  K1按键按下，CAN2发送消息给CAN1，蜂鸣器鸣响4次。
  K2按键按下，CAN1发送消息给CAN2，点亮LED1。
  K2按键按下，CAN1发送消息给CAN2，熄灭LED1。

/*
/ J& j' s- |4 ]) R% V$ H- A" u1 n
*********************************************************************************************************
4 U6 ~# f5 i' b- D5 N
* 函数名: DemoCANFD6 l/ Y4 i& @' p t6 S+ y% f( N7 d
* 功能说明: CAN测试& ~" E0 i% ^4 d7 S
* 形参: 无
% J* B8 ` t! H- a
* 返回值: 无
; Q5 t- U E. ]
*********************************************************************************************************
3 Q L$ k5 F" m. w
*/
2 A L7 D+ [2 j7 n& e) e
void DemoCANFD(void)( P3 {1 D' A" {1 w; H
{- J0 U' W0 K; u
uint8_t ucKeyCode; /* 按键代码 */! e4 ` } ~$ Z0 f7 X5 N- z
2 @( T& p I- Q; T( _5 L7 w6 f" E2 E
can_Init(); /* 初始化CAN */
" K6 W2 G$ U0 ]0 F( s( ^5 p
% | [" A/ d1 P4 ]) J' Z$ V
bsp_StartAutoTimer(0, 500); /* 启动1个500ms的自动重装的定时器 */) P$ v" i L* {, z+ Q7 ]" B+ h
' f) i3 }8 { J9 U: K. P
while (1)7 ^( G- l6 c' C
{
{- ]; M1 X. j+ h
MSG_T msg;
. R. a% A2 A! \, R
) W" Q& G- H: I
if (bsp_GetMsg(&msg))
+ `( I9 Y H8 x' H+ {; o
{; l% x; I2 X' R# M% A
switch (msg.MsgCode)
+ a7 Q3 ]) h. [( B/ ~
{
3 v3 R1 S& g7 B7 x3 y
case MSG_CAN1_RX: /* 接收到CAN设备的应答 */
1 h9 Z; G8 M" }; m1 k9 s
printf("CAN1接收到消息\r\n");% O! I" i% q* }7 y5 V; `( }
can1_Analyze();
1 o. ?+ H5 g6 C* Z* j- p0 u) k; k
break;
7 L( x! O6 m |) [' c
# X2 l* P7 L8 I5 ]( c; e
case MSG_CAN2_RX: /* 接收到CAN设备的应答 */
" Z( P* H; Z8 d) x7 s w) j% ^
printf("CAN2接收到消息\r\n");+ n0 f5 l+ W- M& `9 X
can2_Analyze(); W# L1 v8 T3 I5 ?. | {2 m9 ~0 x
break;
- n+ u# P$ R1 n: P& p" Y
}
7 f& H. K2 x4 \% |% Z2 ~; d
}
( X# H* `6 q" T8 { P3 V! j
}3 C' {( z+ ^, W6 _) Z
! {% o! a& W" E# P% x
/* 判断定时器超时时间 */$ V0 Z2 e. H6 d6 n) G
if (bsp_CheckTimer(0)) 6 q, C7 \4 E: w
{
& J8 M8 p1 F7 ?8 T4 d+ V) y$ ^! {
/* 每隔500ms 进来一次 */ 5 B. [; U/ N" `9 {. }! b9 r; V2 L
bsp_LedToggle(2);
+ v, q* e5 M/ L& N
}0 Z* h* D: e% {# T
" [ Q1 |! x P4 m3 u
/* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */7 K# E8 q6 r9 u' g# l
ucKeyCode = bsp_GetKey(); /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
7 g i& d* U$ p7 G; k+ o/ L
if (ucKeyCode != KEY_NONE)
+ {' J7 ~0 `9 L: |
{
. u' t/ i3 \4 X# @1 {% H6 c. j. t
switch (ucKeyCode)9 t3 ?3 C# w( r' ?& ~" y
{
+ [5 }4 O$ a! c1 m ?! J. J$ K
case KEY_DOWN_K1: /* K1键按下 */
0 W, J% P6 | d# g( B( Q9 H6 _
printf("CAN2发送消息给CAN1，蜂鸣器鸣响4次\r\n");0 O) i& B, P8 y# w
can_BeepCtrl(1, 4);
$ X0 k* y) ]3 R6 {6 _) R7 _
break;
% b& q: }/ l8 y. v
+ M, I* P0 q' q1 B- m) `6 K+ Q
case KEY_DOWN_K2: /* K2键按下 */
( k5 ]+ z5 M2 [4 q* O: n
printf("CAN1发送消息给CAN2，点亮LED1\r\n");7 d- O5 c1 Q2 B1 D
can_LedOn(1, 1);
' r# ^7 f9 z0 Z; B
break;# j1 @& T T& J( ~; d
Y m2 R) A7 ^9 G
$ \# e' \6 H M' W* A1 V5 _6 E
case KEY_DOWN_K3: /* K3键按下 */% _ P+ o8 a; v' z6 {. ^
printf("CAN1发送消息给CAN2，熄灭LED1\r\n");
) x* P0 D) G2 X- H
can_LedOff(1, 1);
3 i4 v8 T: Y8 J1 ]6 R' @; ]3 p
break;, J: ]3 {" r# u/ k8 ^- H1 k
6 c* G E5 U0 [5 ~
default:( k2 ]" Z- I( ]0 M
/* 其它的键值不处理 */5 Z: x. M& E' L7 y' n" B
break;
: y- I& K8 [2 z$ p1 P* b7 m' l! r) n/ V
}* v- I! k+ I1 _1 d
9 w' Y# d" n$ {6 Y
}7 Z9 R; }* Z7 B: g! v
} Y5 B# U& ~7 h! Q8 v6 i
}

复制代码

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

V7-069_双CAN FD之间通信

实验目的：

学习双CAN FD的实现。
实验内容：

K1按键按下，CAN2发送消息给CAN1，蜂鸣器鸣响4次。
K2按键按下，CAN1发送消息给CAN2，点亮LED1。
K2按键按下，CAN1发送消息给CAN2，熄灭LED1。
注意事项：

接线方式是CAN1的CANL1和CAN2的CANL2连接，CAN1的CANH2和CAN2的CANH2连接，具体接线看本工程Doc文件中的截图。
启用CAN1，需要将V7主板上的J12跳线帽短接PA11，J13跳线帽短接PA12。
启用CNA2，硬件无需跳线，要禁止使用以太网功能（有引脚复用）。

上电后串口打印的信息：

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

程序设计：

系统栈大小分配：

RAM空间用的AXI SRAM：

硬件外设初始化

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

/*
: d) _6 @ v1 u3 r
*********************************************************************************************************
6 L [; v5 j& x1 v' q. o& m
* 函数名: bsp_Init
' C$ Z; M& h# @: g# n7 ^4 @/ g
* 功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
3 O/ n$ m" @- {( B# H/ {
* 形参：无
4 R7 u; {: @7 l7 v* g
* 返回值: 无" x5 |# g+ j2 S& Y0 D$ A
*********************************************************************************************************- l9 {7 O: h' Z7 r/ e5 _- @
*/
5 d# s9 A9 Y7 b
void bsp_Init(void)5 }0 Y- n$ l7 c% G- y; B
{
9 ?8 K2 _/ c- r! C+ U* `
/* 配置MPU */
2 q- O; C' E' t5 X8 O: W8 K
MPU_Config();7 v7 k6 x; r8 l9 z5 e
4 U) s! V$ H6 ~" X$ b! s
/* 使能L1 Cache */
8 t' g& b; y: H. t
CPU_CACHE_Enable();2 @$ c2 Q; K. u; x1 g) [5 l9 ?
8 v& M, ?7 Y& A. ]! y5 L, c
/*
( L6 x2 e9 K7 b# F6 m0 H) x
STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
# S. M8 m0 ?( p E% K/ W
- 调用函数HAL_InitTick，初始化滴答时钟中断1ms。0 S. g# q% m4 V. \6 E$ c
- 设置NVIV优先级分组为4。
8 n2 ~; l7 i* P7 p
*/0 {& u8 p( O* }
HAL_Init();
z3 b3 j- j! q4 B
# ]3 i4 s: V3 J, p( E6 R7 w/ D
/*
+ `8 t. x. M6 W
配置系统时钟到400MHz. M! [! i8 d7 R. f6 n, k
- 切换使用HSE。% Z; J8 Z+ D0 U
- 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。 ?+ d# J; d- r- p: b: t
*/9 M& R5 }: T: r6 U, a5 `( i
SystemClock_Config();, l. ?! S5 W7 S7 \/ Y/ r3 A7 L7 A
* E/ a0 `8 z# N2 p$ N$ J4 }
/* : u/ C9 ^4 E! ]6 B
Event Recorder：7 X9 p1 K, ^- G- v1 o
- 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。2 {7 J5 q' w5 @
- 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
! }# l( a p6 X3 \( |; D- q4 A3 ^
*/ ) Y: g- k" M, ]1 N
#if Enable_EventRecorder == 1 , P) L" H% _* p, v C2 N
/* 初始化EventRecorder并开启 */
Z3 d4 g- f4 `. B: |9 n
EventRecorderInitialize(EventRecordAll, 1U);: k- g4 ], q+ V1 U/ n. R& ]2 Y
EventRecorderStart();
F( ]! Z% _1 [
#endif8 y# q# e9 B- J# i( S, V0 w
( E3 M1 V* q8 [% x
bsp_InitKey(); /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
1 @+ u; u; d" R" _
bsp_InitTimer(); /* 初始化滴答定时器 */8 B \4 m7 M$ l
bsp_InitUart(); /* 初始化串口 */
& }! |; |5 ]: p% U6 d8 J
bsp_InitExtIO(); /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */
; I1 r3 H+ T+ j( p3 z
bsp_InitLed(); /* 初始化LED */ , q3 O; a% q1 P; V2 W, [$ v/ {* _
}

复制代码

MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区和FMC的扩展IO区。

/*' U8 l( Q% L; z+ S. c
*********************************************************************************************************6 Z! O7 W7 Y# \4 t: x h' c: l
* 函数名: MPU_Config
* E" N+ l0 `8 E& _# D. s ]
* 功能说明: 配置MPU! c9 D4 G7 T; y' o: p1 A4 u
* 形参: 无
- r. q3 ?1 P# B( A
* 返回值: 无" ] a/ N/ E" X) v& x5 @$ b
*********************************************************************************************************$ N. Z5 Y+ g# }6 n8 w+ s1 e
*/; A: ?% Q5 e4 g. z3 _
static void MPU_Config( void )# g) o7 k$ z$ G# ~& ?* L4 f+ O. e
{8 ]3 n5 {* q6 r$ S/ `8 i4 J
MPU_Region_InitTypeDef MPU_InitStruct;
3 z* ~+ |5 }1 U' u! W
" o: v% k/ y- T" G5 N3 q" `! p
/* 禁止 MPU */
( g) a9 H( q$ O5 }- W0 H
HAL_MPU_Disable();
- k' k z: |6 V5 ], O7 J) ?
" _6 d- R, a4 l3 F8 b$ b
#if 0- h! h y- n4 o6 ?
/* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
+ v: J, b& ~$ F# e
MPU_InitStruct.Enable = MPU_REGION_ENABLE;
6 m# ?" x- E5 [% V
MPU_InitStruct.BaseAddress = 0x24000000;% X9 @- S7 O8 j
MPU_InitStruct.Size = MPU_REGION_SIZE_512KB;& c3 W: X& P; l& R9 z
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
, H% C% w* e8 q3 ~/ ^) _! P# F
MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE;5 C$ ~( u# R9 L/ ?# q/ ^
MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;# A9 r6 z5 n* I$ [" `
MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
& G* E! ?' n( e4 x0 B
MPU_InitStruct.Number = MPU_REGION_NUMBER0;, g& s2 f6 d. H" D$ n/ K+ z2 |. S
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL1;
/ N7 u- V6 b, e, U% a9 x% q, i
MPU_InitStruct.SubRegionDisable = 0x00;* A, H5 J) R# H2 N9 u
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;( d, J7 r! t+ ]8 n( ]6 ?( y+ V
; ^' |% h/ q7 x: A& Q
HAL_MPU_ConfigRegion(&MPU_InitStruct);
l8 i: t- e2 D, `+ {2 N. T* q
# ^" B- i+ T% q5 m
#else
, L1 n! T, e5 o
/* 当前是采用下面的配置 */0 e7 u1 C% S3 H8 P1 c3 I) |
/* 配置AXI SRAM的MPU属性为NORMAL, NO Read allocate，NO Write allocate */
& `8 y% x4 G0 N
MPU_InitStruct.Enable = MPU_REGION_ENABLE;% Z6 I0 g9 a4 {9 Z4 r
MPU_InitStruct.BaseAddress = 0x24000000;) \) Z+ z6 m$ x) u5 \
MPU_InitStruct.Size = MPU_REGION_SIZE_512KB;' S# D% A; w3 P3 u* C7 [( W
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;- V1 @8 [) h, H: V% V8 \
MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;
# {# N+ y0 `) U* k5 H
MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE;& t# y9 F$ {0 \9 F k, v; ~/ ^
MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;; y B4 G) u; D+ \# A
MPU_InitStruct.Number = MPU_REGION_NUMBER0;
9 w/ _8 V+ ^/ W/ V, E
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL1;
7 k% {' g3 w5 @) q
MPU_InitStruct.SubRegionDisable = 0x00;
' j' E/ f5 j8 J* j" z( w- k# a0 e$ j
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;
" v7 f( O) ~$ V! e
% p% o( v; i8 O1 }
HAL_MPU_ConfigRegion(&MPU_InitStruct);2 K, @# o: q6 u, G+ m) C+ o
#endif, n/ d8 F- b# [8 K1 y
/* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
3 u6 S7 j4 q F0 l% M! B5 V2 I; P
MPU_InitStruct.Enable = MPU_REGION_ENABLE;
5 }) T2 M* Q3 J. |- `
MPU_InitStruct.BaseAddress = 0x60000000;. W- I9 h! z7 G8 H
MPU_InitStruct.Size = ARM_MPU_REGION_SIZE_64KB; ; f: z' F& r3 s
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
2 V9 l* f/ i& b6 g
MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE;
$ t$ g$ O& q6 t- I! H9 L
MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE;& O8 m* e% J( j6 R6 F
MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;- {9 b U- R A! a, ]
MPU_InitStruct.Number = MPU_REGION_NUMBER1;
* B$ j: e+ N+ B4 d
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;
& G- l$ Z( q2 ^4 k+ b! ~! v
MPU_InitStruct.SubRegionDisable = 0x00;( ]6 p! F' f5 i* p" n9 m" e! d% X6 m
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;
5 B! l, @; x* S6 B8 ?) W
2 C/ [/ a$ A/ G+ k: ]" R
HAL_MPU_ConfigRegion(&MPU_InitStruct); c! \' p' D+ a1 W3 z" p' y5 X
' a! Y @9 m3 ~8 I2 X7 p
/*使能 MPU */+ ^3 N2 a7 ^$ [9 R* l2 j& z
HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);8 b9 T+ z/ ~0 u+ t B3 R
}
2 t* e6 E0 I, K! R5 C, v# _
3 T" i, N& n* ^' P4 R% l: r \
/** n* _% B1 C4 @
*********************************************************************************************************' S' x h! z) |2 u1 C7 r
* 函数名: CPU_CACHE_Enable* y1 r4 k1 ` p8 _' \0 T
* 功能说明: 使能L1 Cache
( C/ a! U' l1 D- O8 P2 m4 |
* 形参: 无
% `1 }3 O+ j4 p7 Z |$ A8 d
* 返回值: 无* @# `. A& Y& Y1 d
*********************************************************************************************************$ @, Q2 [9 c+ B2 e+ F) ?
*/5 B# D1 }& k- V( Z- G) }( Z& E: \3 @
static void CPU_CACHE_Enable(void)
: M% e. M$ w6 S/ O
{3 s! X" r; o/ s5 |
/* 使能 I-Cache */5 G# I+ B' W8 b1 ]2 ~8 `
SCB_EnableICache();1 B/ X" m+ P: a! Q
! h6 O7 Q/ L4 j: {6 W: v
/* 使能 D-Cache */
& W- D3 C2 k2 K4 { j! S8 r
SCB_EnableDCache();
: Y* i) U B; _9 c# {
}

复制代码

/*
8 k' n3 e7 N$ E
*********************************************************************************************************
( }7 Y; {/ C4 J* k- [! h
* 函数名: DemoCANFD, y* _, ], H" g n) ^
* 功能说明: CAN测试
# m+ s ^0 a- i
* 形参: 无 n7 W& ?1 ^, i) h7 O Q
* 返回值: 无
( M! Z( {' C& U9 N/ a& b2 i# z
*********************************************************************************************************4 W) }' f2 k0 T
*/& \9 e2 R2 L* o/ d: {
void DemoCANFD(void)5 ^5 G& d# A* z1 ~5 m
{
7 B- A7 ?0 a! z
uint8_t ucKeyCode; /* 按键代码 */+ {! s6 [. o) C" A$ @: t
6 R6 E! K1 F8 t* a" R0 i* D; U
can_Init(); /* 初始化CAN */% A* d, T# s8 b1 A3 F5 O0 K
' w. j" m2 ~$ A4 s* r1 [
bsp_StartAutoTimer(0, 500); /* 启动1个500ms的自动重装的定时器 */0 c- Z; B2 l+ T' [. N
7 D# W5 p x5 ^
while (1)
/ |; i+ d' ]- v2 \ C( |
{+ ] j8 Q& k1 N2 ]6 c; [8 _* E' I
{& b2 n6 L0 o8 }5 {
MSG_T msg;. k! L- j! O$ T1 |
2 O2 g- ~ S# G/ [ [; W- d/ E
if (bsp_GetMsg(&msg))" X4 E. u' r: x/ a
{
, s: ]0 @1 {- Z4 }
switch (msg.MsgCode)) f, [6 }+ r5 }/ M. z/ v
{# R7 z) I0 b7 N7 [2 h7 ~' L4 E
case MSG_CAN1_RX: /* 接收到CAN设备的应答 */! t0 r2 F6 h2 U, \6 k) {
printf("CAN1接收到消息\r\n");
' z; w/ Q; @4 I2 J
can1_Analyze();
. w) _* h3 M6 R. f" M
break; / c8 T3 E: d9 u4 }2 r
8 x" i/ y9 _% M/ Z* C: Z/ k
case MSG_CAN2_RX: /* 接收到CAN设备的应答 */
- `* Y$ e/ }8 J$ a8 s
printf("CAN2接收到消息\r\n");$ f& P' i! v8 V+ T* V# z
can2_Analyze();
2 D: O& X" K# h8 O" o0 i
break; 0 k$ I1 b8 Q' \1 T4 q
}
3 J5 x0 c6 z# Q7 g, S2 a
}
$ g# v' U6 i9 v9 W7 q
}
! ?! y( K& @; v' ~" r
( a( K6 z9 n9 O6 h
/* 判断定时器超时时间 */5 t9 C$ j4 C/ e- U$ s) b _
if (bsp_CheckTimer(0)) + I, ~4 W1 X1 F9 \4 Y0 P) [
{
7 S8 e4 H# Z" R% \' @; h8 {! Q
/* 每隔500ms 进来一次 */ " {, L% T6 d$ l
bsp_LedToggle(2);: q* C3 e' u G9 O! O
}
- _! b0 k' \ Z7 o0 Z! M
" G) p" u E+ S) v, D
/* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
# e% J6 K9 t0 j( H- v ~
ucKeyCode = bsp_GetKey(); /* 读取键值, 无键按下时返回 KEY_NONE = 0 */0 F" J% R: X" {, T
if (ucKeyCode != KEY_NONE)
& @6 W+ N, M# J1 i
{ g& N8 I7 K ~! Y3 B& o1 @9 ~
switch (ucKeyCode)
i% p( r* ^6 F" S% f/ J
{, f2 j1 D$ G; r& h3 R
case KEY_DOWN_K1: /* K1键按下 */
+ i* a; \4 N) U% ~5 X
printf("CAN2发送消息给CAN1，蜂鸣器鸣响4次\r\n");6 h7 d7 k; y {+ ^' n: J R% J
can_BeepCtrl(1, 4);, _0 Z* [% F' y6 }. s7 _! _6 N+ v" v
break;% E: b: ]' L6 H; a
N& A' r& u3 y; q4 ~$ }, }6 w
case KEY_DOWN_K2: /* K2键按下 */
! l1 T- ^9 [- m; {! O
printf("CAN1发送消息给CAN2，点亮LED1\r\n");& y5 }) G4 p$ `3 q2 z' r6 g3 ]
can_LedOn(1, 1);2 \3 n+ G" j- W2 ?1 H
break;
/ a8 g0 @% B. K! P9 [) u
2 a* K4 i. {: ?4 d
. U! h# z; A7 `& k
case KEY_DOWN_K3: /* K3键按下 */
0 @9 k1 l5 n4 c
printf("CAN1发送消息给CAN2，熄灭LED1\r\n");. A, S% q, V0 U
can_LedOff(1, 1);
9 y( G0 |; f3 E8 a9 ]9 N1 M
break;
: k+ J# O) Z( _
' {- _/ `4 x. `5 w$ S# K; E, d
default:
/* 其它的键值不处理 */( q/ G% t# m( } x9 f' V8 |& u/ G e
break;4 D3 j1 ] ?8 x) w$ S1 G6 r' i* g4 L/ X* P
}
" G x: n* q- @: d
! x U( M8 D3 V, Z U( C W9 w
}
9 B1 Z# B: d; h9 M8 }+ o9 R6 P
}2 @* o) `& H' V o4 w0 j" [
}

复制代码

92.10 总结
本章节就为大家讲解这么多，FDCAN涉及到的知识点非常多，建议先将例子熟练运用，然后再深入了解。

赞收藏评论0 发布时间：2021-11-6 23:52

0个回答

【经验分享】STM32H7的FDCAN总线应用之双FDCAN实现（支持经典CAN）

所属标签