FDCAN 与 经典CAN 的最直观差别就是数据帧部分，FDCAN的数据帧波特率可变，并且数据大小不局限于 8 Bytes ，最高支持 64 Bytes 的数据传输。详细差别见 传送门： CAN FD 与 CAN协议区别–简单易懂协议详解 。
3 J: y* `# n  B# q8 C
1. FDCAN的框图
% q9 G# m, T6 r, n, p% b5 u# e


* [/ M9 [$ K' y: \* O# i根据上图可以看到，FDCAN 有两个时钟域，APB总线接口和CAN内核时钟。FDCAN的波特率取决于内核时钟；寄存器的配置、消息RAM等，走的是APB时钟。FDCAN的APB时钟在RCC_APB寄存器中配置，内核时钟在RCC_CCIPR寄存器中配置（下一章）。
FDCAN有两个中断线，这两个中断线可以单独的打开或关闭，在FDCAN_ILE寄存器中配置。
# q' l# m7 H2 ^* H其他具体介绍参考DM00355726_ENV4手册的1947页（RM0440手册官方下载传送门）。
) {  s: M- {2 j' c6 m6 c
; f% Y# Q: R% l* Q! I2. FDCAN的时钟与波特率
2.1 fdcan_clk
. g& }. R" U. D& M7 v8 r几乎所有通信都可在RCC中配置时钟选择，FDCAN的时钟（fdcan_clk）可在RCC_CCIPR寄存器中进行配置。

$ @3 }' F. e$ h3 R' y
' @2 r6 u* b& g, a' B+ p2 |3 m' g
! ^: [: e& p; G' Q! d& |: `FDCAN1/2/3 的内核时钟是通用的，可以在配置FDCAN1的时候，配置 CKDIV 寄存器进行进一步的分频（INIT标志位置位才可配置该寄存器），这里配置的CKDIV影响到 FDCAN2 和 FDCAN3。

1 a& g: ~9 \  |. j' }6 r7 N0 k2.2 fdcan_tq_ck
* t- `* [* J3 i根据系统框图可看到，系统输入的时钟可通过 fdcan_clk 分频得到 fdcan_tq_ck ，在 FDCAN_CKDIV 寄存器中配置分频系数。
0 G5 ~# @: H. Q7 J& G5 x
; p2 V* {8 g; ~2 S: o# P

可以认为FDCAN内核用的时钟都是fdcan_tq_ck ，只不过 fdcan_tq_ck 为1分频时候认为是fdcan_clk 。

- H& F! @1 {5 v2 _2 A! p4 n% l4 s  [( {2.3 波特率
FDCAN模块的bit采样分三段：
0 x1 M4 U  t& c, w2 \/ m1 P. G
3 K7 A" H6 t+ z' S8 a% e
! p" ?' v0 T4 K* X$ y) J

. e8 T7 k/ m9 Z- A4 y. C波特率公式如下：

% D* P/ q: s5 l1 D. s2 e4 c9 R& ]8 c注意：
1、由于 FDCAN 与 经典CAN 的帧格式有点差异，其数据帧波特率可变，因此在这里分出普通CAN和数据bit时间
2、数据 和 普通 bit 时间寄存器名称不一样，数据波特率寄存器 FDCAN_DBTP ，一般帧波特率寄存器为 FDCAN_NBTP 。当使用经典模式CAN时， FDCAN_DBTP 配置被忽略

3. FDCAN的地址分布
3.1 总体分布

8 D# q; _7 j9 A
. F  n3 P0 b9 |) A. ]
由于头文件中没有该寄存器的宏定义，因此需要自己建立宏定义。
G474的FDCAN外设一共有3组（FDCAN1，FDCAN2，FDCAN3），寄存器配置分为3个，消息RAM也分为3组。

3.2 Message RAM
2 p8 T9 V% a7 d6 @$ c( j
6 E5 M, p) |& B5 `8 o' f2 w

1个 信息RAM 有 212 words 的大小，即 212 × 4 = 848 Bytes 。
. C+ [' g8 D0 E" I- z
根据3.1和3.2可以先把 消息RAM 的宏定义写好

; @* M8 H1 T# G+ A4 v

1. #define FDCANs_MESSAGE_RAM_BASE                                        0x4000A400
   
2. #define FDCAN1_RAM_BASE                                                        (FDCANs_MESSAGE_RAM_BASE)
   
3. #define FDCAN2_RAM_BASE                                                        (FDCAN1_RAM_BASE + 0x00000350)
   $ p0 M. c  k% p) r
4. #define FDCAN3_RAM_BASE                                                        (FDCAN2_RAM_BASE + 0x00000350)
   
5. 
   
6. typedef struct
   3 m$ n+ J* s% r& V, L" p
7. {
   
8.         uint32_t FILTER_11BIT[28];                //0x4000A400 ~ 0x4000A470
   2 x3 b  A# h0 ^) V" t
9.         uint32_t FILTER_29BIT[8][2];        //0x4000A470 ~ 0x4000A4B0
   $ u! W+ h/ X' |; d- ~- C/ P
10.         uint32_t Rx_FIFO_0[3][18];                //0x4000A4B0 ~ 0x4000A588
    
11.         uint32_t Rx_FIFO_1[3][18];                //0x4000A588 ~ 0x4000A660
    
12.         uint32_t Tx_FIFO[6];                        //0x4000A660 ~ 0x4000A678
    1 w3 X$ u: p! A. e. f3 b
13.         uint32_t Tx_BUFFER[3][18];                //0x4000A678 ~ 0x4000A750
    
14. }FDCAN_RAM_Struct;
    
15. 
    
16. #define FDCAN1_RAM                                                                ((FDCAN_RAM_Struct *)FDCAN1_RAM_BASE)
    1 H6 z- \9 G2 {+ _6 W$ C* C+ b
17. #define FDCAN2_RAM                                                                ((FDCAN_RAM_Struct *)FDCAN2_RAM_BASE)
    * i: e1 G4 z4 S+ j% @
18. #define FDCAN3_RAM                                                                ((FDCAN_RAM_Struct *)FDCAN3_RAM_BASE)

复制代码

注意！！！ 上面的代码第1行的宏定义部分，偏移为 0x350 而不是 0x400。
曾经我根据 3.1里面的图片进行配置（0x400也就是1KB），结果只有FDCAN1好用，FDCAN2和FDCAN3都不能使用，困扰了我一天来找这个问题，后来使用 0x350 就可以了，可能是手册写错了，也可能是我的理解与有误。
这里是个坑，希望大家能够规避一下。

1 x: Z0 A9 G2 [. Y7 j2 @7 Y# H4. FDCAN中断配置
4.1 中断寄存器
4 V4 j  X# }- OFDCAN中断配置中，涉及的寄存器为
! W2 \. P9 c  w* K7 E; aFDCAN_IE 与其他外设的IE一样，中断使能寄存器，在这里选择使用的中断，在代码中会注释
# ?- e. ^% J& ~2 G3 `FDCAN_ILE 中断总线使能。FDCAN中将中断分为了两个分支，即有两个中断函数
/ g; S) n( T: ^. y' i+ k" E3 LFDCAN_ILS 中断总线选择。在这个寄存器中配置哪个中断归属于哪个中断分支，默认都为分支0.
% S5 V" t6 }* K  n. E" ^9 h
: g3 @" R  q. B% b4 M2 {" W$ t

5. FDCAN的筛选器
5.1 筛选器的特征
$ J* b4 }( r, H7 Y, E每个筛选器可配置为
" d9 n; T4 Q4 O! y• 范围筛选
• 指定ID筛选
2 B/ }( B- H1 Q% Y* q7 P% A• 屏蔽典型bit筛选
: Z* g+ ^6 }% Q' [3 ~" g& K每个过滤器元件可配置为接受或拒绝过滤
每个过滤器元素可以单独启用/禁用
过滤器是按顺序检查的，执行在第一个匹配的过滤器元素时停止
相关的寄存器：全局筛选配置（RXGFC）、拓展ID和掩码（XIDAM）
1 H0 b3 h' w+ Q3 Q
: D* l$ ~1 b5 i! w如果需要接收数据，一定要配置筛选器，否则会什么也接受不到。
9 U5 Z9 G8 U: d
( Q+ R  {5 H4 T0 j( o& e- ~, P5.2 11-bit 筛选器的格式
% X& |5 {& h( F
) u/ Y- Z) t- O7 V0 _) r8 ]
* {8 [5 E+ t; l3 c/ I
# ~  Q, m+ X0 f这里根据手册的翻译进行配置就好，29-bit 的筛选器也是如此，手册里全有，我就不放图片了，太占地方。
, m% |! `, e+ `7 X2 {: j6 \: A
通过配置筛选器，可以使FDCAN外设接收其他模块发来的信息，在筛选器中配置接收消息的FIFO或者拒收消息。配置筛选器是FDCAN接收的关键。
$ {! T7 R; z; K# g5 }筛选器的配置不受 INIT 和 CCE 标志位的限制，可随时配置。

6. FIFO模式与Queue模式
' G, f& k: [9 x3 F0 @, xFIFO模式与队列模式的区别为：

) e$ z4 m1 |7 t$ U# o! Z. J1 N' t队列模式的优先级遵循邮箱0优先级最高，其次是1，最后是2，如果当前3个邮箱全有数据，优先发送邮箱0的数据
- Q: y" ^* v. G$ lFIFO模式的优先级是遵循哪个数据先进入的邮箱，与其所在的索引地址无关，即：如果当前3个邮箱全有数据，邮箱2被最先写入，则优先发送邮箱2的数据。

- J  ]4 ]$ @8 s  A3 s6.1 TX FIFO 的寄存器格式

! T( o4 H' T. A
具体说明见手册1969页，我就不复制了，翻一下就能懂每个BIT代表的意思。
根据上表，我们就可以写出对应各个标志位的结构体，方便后期指针使用。
  h9 ?5 N9 a' Y' y  s  E0 S# G由于其buffer支持 11-bit ID 和 29-bit ID
5 _* S! y0 D% m+ F6 d
7. FDCAN的初始化
IO口配置我就不介绍了，想必大家都会配置IO。
' C* n" a  J% V6 T/ v' y1.首先在RCC->APB1RSTR1寄存器中使能RCC_APB1ENR1_FDCANEN，这样FDCAN的寄存器就可以配置了。
3 y- u# W0 o8 y. m; n- d2.然后选择FDCAN内核时钟的时钟源，在RCC->CCIPR寄存器的RCC_CCIPR_FDCANSEL中配置。
3.置位INIT标志位，开始配置寄存器（只有INIT标志位置位，才可置位CCE标志位）
2 D5 p# C3 g# P' ^! A& K4.等待INIT标志位置位
5.置位CCE标志位，解锁受保护的寄存器
6.等待CCE标志位置位
; e  A' H0 j7 r2 K# v: {- D7.配置时钟分频 （FDCAN_CKDIV 寄存器）
" i' M  j5 q& o8.配置波特率
9.配置中断
# m/ T1 `% u, V10.使能筛选器
11.配置筛选器
. d. g9 v: b' G9 v3 [6 s7 G: s清除INIT标志位
到此，FDCAN就配置完了，具体操作见代码
初始化代码见
" O1 b# P: i2 I
8. 发送操作
" J/ p, _: v% ^/ }  ?8.1 FDCAN帧模式
4 @# Y, P# j" U1 P5 o6 W) sFDCAN帧模式由下表各个标志位配置：
$ e- S+ r/ m; I/ |& N- D
1 v& ~; e# c8 H( T5 c  @
  Z6 M, y; ?6 A/ @; P
. O+ l& P0 y$ B7 D根据上表所示，可以通过 CCCR寄存器 和 Tx Buffer 内部的标志位 配合，实现不同模式的CAN。
由于鄙人只想使用 经典CAN，因此将 CCCR寄存器 中的 FDOE 配置为 0，其他标志位我就不管了。
6 g3 b, l, c8 n: N3 h5 f! H4 D
' o& L+ s" o. f7 ?" }- q# m8.2 发送步骤
- i5 b6 y/ M% ?8 D8 T  Q7 O: F读取 FDCAN1->TXFQS 是否有可用信箱（ FDCAN_TXFQS_TFQF 是否置位）
; I! U" x4 F* i% D- P8 U  j如果没置位邮箱满标志，则查询 FDCAN_TXFQS_TFQPI 索引，获得的索引就是可以写入的邮箱
将要发送的数据写入刚才读取的索引的 Tx Buffer 中（在这里可以配置发送长度、ID等信息）
) @! \1 ^  @' j+ Z! E& M6 j% U置位发送请求
  `5 {4 ^, c/ B% h2 ?  u等待发送完成（可以不等待，配置发送完成中断使能后，在中断中置位发送完成标志来判断是否发送完毕）
9 Z2 }7 J+ A- l- H1 U- }$ d* a示例代码见
附录2 发送函数
3 R3 j5 {) V. B/ I9 x- R代码中的部分宏定义是根据手册定义的，由于太长就不放在这里了，完整代码在 代码下载
& S7 T" V0 ]0 D$ }
# b1 k# M8 q  L9 }1 \9. 接收操作
首先配置筛选器来选择接收的消息和接收后存放的FIFO。
8 ]+ J+ o: [9 q" n6 N
接收分为 覆盖模式 和 阻塞模式 。
覆盖模式 顾名思义，就是当FIFO满了以后，接收到新消息后覆盖老消息。
7 X% J) q# B& \4 R% J4 q阻塞模式 就是当FIFO满了之后，忽略新消息，保留老消息。

" @0 s+ p* G3 Y0 ]当 Rx FIFO 0 接收到消息后，将会在 FDCAN_RXF0S 寄存器中 F0GI 标志位指示新消息存储索引，当 CPU 读取这些消息后，务必将最后 F0GI 的值写入到 FDCAN_RXF0A 的 F0AI 标志位，来确认来读取完毕，这会将 FDCAN_RXF0S寄存器中的索引标志位 F0GI 设置为 F0AI + 1 并更新 FIFO 0 的存储计数 （FDCAN_RXF0S 寄存器中 F0FL 标志位，范围0~3），如果不确认读取完毕，将会导致指示索引 F0GI 失效。

: M" n0 a' t9 W- J2 w" k接收操作可以在中断中进行，通过配置 FDCAN_IE 寄存器中的相应 中断使能标志位 来开启中断，具体示例见初始化代码。如：使能 FIFO0 接收新消息中断就置位 FDCAN_IE_RF0NE 标志位。
1 k$ j2 K  y, F- W
! j6 u7 L2 A( r& s/ Y7 y因此，接收操作的步骤为：
1.读取接收的数据
2.确认读取完毕

7 N# m7 C4 d; B5 C5 S4 S10. 故障
故障处理这里就不介绍了，值得注意的是：
当CAN两个总线短接，超过一定时间后，FDCAN会因为不能检测到有效电平而置位故障标志，同时置位初始化 INIT 标志，导致CAN关闭，排除硬件故障后可直接复位 INIT 标志来恢复故障前的运行状态（也就是说可以正常收发数据了）。

& d( j) U2 m4 K) C6 c11. 参考资料传送门
+ T. l6 p: E! T/ A2 n! m/ y1 P7 f11.1 代码下载（0积分）
! p- i9 X" _5 z+ w9 }代码下载（0积分）
; G/ \$ y9 ^4 G% W
11.2 其他 CAN 知识了解
其他 CAN 知识了解

& c4 s8 N8 T$ L- ?7 R: O4 t附录1. FDCAN寄存器配置
返回第7章 FDCAN的初始化
返回第9章 接收操作

1. /**
   : u& O: V6 i8 w) b
2. * @description: FDCAN1 初始化
   , ?" y7 l$ m3 f- ?: F$ n" e
3. * @param {*}
   
4. * @return {*}
   
5. * @author: XL
   6 Y: M9 P4 B) [5 W$ M+ i0 n
6. */
   
7. void FDCAN1_Function_Init(void)
   7 I# D7 {; u( }0 Q9 V' ]" u
8. {
   & [) A8 p: ?8 L
9.         //在RCC_CCIPR寄存器中选择FDCAN时钟为HSE，即8MHz
   5 h3 N* q, [/ W2 m% b: N6 `& h
10.         //
    
11.         FDCAN1->CCCR |= FDCAN_CCCR_INIT;                                //步骤3 置位INIT标志，开始配置寄存器（只有INIT标志位置位，才可置位CCE标志位）
    
12.         while (!(FDCAN1->CCCR & FDCAN_CCCR_INIT));                //步骤4 等待INIT标志位置位
    3 V$ U# V, [) N. y# [! p3 \
13.         FDCAN1->CCCR |= FDCAN_CCCR_CCE;                                        //步骤5 置位CCE标志位，解锁受保护的寄存器
    3 [  T) i& V. g- m+ y2 l! ^
14.         while (!(FDCAN1->CCCR & FDCAN_CCCR_CCE));                //步骤6 等待CCE标志位置位
    6 u% p) M+ Z0 @! G) Y# ^
15.         FDCAN_CONFIG->CKDIV = 0x0;                                                //步骤7 配置时钟分频
    : ^/ B4 k5 }, h' \' Y
16.                                                                                                 //只允许在FDCAN1初始化中配置
    
17.                                                                                                 //fdcan_clk = 168 / 1 = 168 MHz,影响到FDCAN2、3（FDCAN_CONFIG地址上来说，还是属于FDCAN1）
    
18.         FDCAN1->CCCR |= 0
    
19.                                         // |FDCAN_CCCR_NISO                                //bit15: 【0|ISO11898-1】【1|CANFD v1.0】
    
20.                                         // |FDCAN_CCCR_TXP                                        //bit14: 【1|在下上一个成功帧后暂停两个bit再起始】
    ( W1 r" O3 ]: w6 Z
21.                                         // |FDCAN_CCCR_EFBI                                //bit13: 【1|同步检测边沿需要两个显性tq】
    6 B$ r1 @6 C- Q
22.                                         // |FDCAN_CCCR_PXHD                                //bit12: 【0|启动协议异常处理】【1|禁用协议异常处理】
    0 [% }3 ]( W. D" A) L
23.                                         // |FDCAN_CCCR_BRSE                                //bit09: 【1|启用波特率切换】
    $ E: J5 G; \4 f; i9 i' V
24.                                         // |FDCAN_CCCR_FDOE                                //bit08: 【0|FD操作禁止】【1|FD操作使能】
    + t& a- r" r. H. ?& H
25.                                         // |FDCAN_CCCR_TEST                                //bit07: 【1|测试模式使能】
    
26.                                         |FDCAN_CCCR_DAR                                        //bit06: 【0|启用发送失败后自动重传】【1|禁止自动重传】
    
27.                                         // |FDCAN_CCCR_MON                                        //bit05: 【0|总线监控模式禁止】【1|总线监控模式使能】
    7 @8 V0 E  v2 \- q
28.                                         // |FDCAN_CCCR_CSR                                        //bit04: 【0|无时钟停止请求】【1|时钟停止请求，当时钟停止请求发生，先置位INIT在置位CSA在所有传输请求完成并且CAN总线空闲】
    : a: ]+ Q( `! A: F- }
29.                                         // |FDCAN_CCCR_CSA                                        //bit03: 【0|没有时钟停止】【1|FDCAN可通过停止APB时钟和内核时钟来进行掉电】
    4 P( y' p1 ~5 }/ A; b& b
30.                                         // |FDCAN_CCCR_ASM                                        //bit02: 【1|启用限制模式，限制模式下不会主动发送数据】
    8 H: Q: C- P( f; V- B
31.                                         // |FDCAN_CCCR_CCE                                        //bit01: 【1|允许配置受保护的寄存器，INIT标志位必须置位】
    4 `% A5 L% v7 k7 E( U. s
32.                                         // |FDCAN_CCCR_INIT                                //bit00: 【1|初始化开始】
    
33.                                         ;
    
34.         // FDCAN1->DBTP = 0                                                                //数据帧的波特率（FDCAN模式需要配置，经典CAN不需要配置）
    
35.         //                                 |FDCAN_DBTP_TDC                                        //bit23: 【1|收发延时补偿使能】
    
36.         //                                 |(0 << FDCAN_DBTP_DBRP_Pos)                //bit[20:16]: tq = (BRP + 1)*fdcan_clk
    ( K; `# J# O( H: c$ A% l6 c
37.         //                                 |(22 << FDCAN_DBTP_DTSEG1_Pos)        //bit[12:08]: 一阶段采样                        8000000
    4 q+ f/ S6 B' v9 F
38.         //                                 |(7 << FDCAN_DBTP_DTSEG2_Pos)        //bit[07:04]: 二阶段采样 波特率 = 8000000/(3+DTSEG1+DTSEG2) = 8000000/32 = 250k
    3 L  o9 O3 F# Z# ~4 `
39.         //                                 |(4 << FDCAN_DBTP_DSJW_Pos)                //bit[03:00]: 同步脉宽
    
40.         //                                 ;
    5 k& p7 u& x% n9 I' S; Q! Z
41.         FDCAN1->NBTP = 0                                                                        //步骤8 配置波特率
    
42.                                         |(4 << FDCAN_NBTP_NSJW_Pos)                //bit[31:25]: 同步脉宽 必须小于SEG2
    
43.                                         |(0 << FDCAN_NBTP_NBRP_Pos)                //bit[24:16]: BRP   tq = (BRP + 1)*fdcan_clk
    
44.                                         |(22 << FDCAN_NBTP_NTSEG1_Pos)        //bit[15:08]: 一阶段采样
    ' |1 ^* G  _1 h9 v' {
45.                                         |(7 << FDCAN_NBTP_NTSEG2_Pos)        //bit[06:00]: 二阶段采样 波特率 = 8000000/(3+DTSEG1+DTSEG2) = 8000000/32 = 250k
    
46.                                         ;
    ' ]( r' S  u% y0 S* }3 U
47.         //步骤9 配置中断
    
48.         FDCAN1->IE |= 0
    * a, ^0 ^, q2 w6 l8 M6 E; r( w$ H
49.                                         // |FDCAN_IE_ARAE                                        //bit23: 访问保留地址使能
    : A1 Q$ B( I( o* E; ?) y
50.                                         // |FDCAN_IE_PEDE                                        //bit22: 数据阶段协议错误
    
51.                                         // |FDCAN_IE_PEAE                                        //bit21: 仲裁阶段协议错误
    + a# X" q( Y" Z# b) X! n
52.                                         // |FDCAN_IE_WDIE                                        //bit20: 看门狗使能
    8 v" [7 N4 Y: P
53.                                         // |FDCAN_IE_BOE                                        //bit19: 总线关闭使能
    
54.                                         // |FDCAN_IE_EWE                                        //bit18: 警告状态中断使能
    
55.                                         // |FDCAN_IE_EPE                                        //bit17: 错误被动中断使能
    + e" u- o1 U- |6 W- d
56.                                         // |FDCAN_IE_ELOE                                        //bit16: 错误记录语出中断使能
    + s" m; p/ \2 ~3 D3 ~6 Z! Q; y2 `
57.                                         // |FDCAN_IE_TOOE                                        //bit15: 超时中断使能
    
58.                                         // |FDCAN_IE_MRAFE                                        //bit14: 信息RAM访问失败中断使能
    # y% E) r9 H4 a' W  ~% P; T
59.                                         // |FDCAN_IE_TSWE                                        //bit13: 时间戳重复中断使能
    
60.                                         // |FDCAN_IE_TEFLE                                        //bit12: TX事件FIFO元素丢失中断使能
    1 U' y9 l: p: j' d
61.                                         // |FDCAN_IE_TEFFE                                        //bit11: TX时间FIFO满中断使能
    
62.                                         // |FDCAN_IE_TEFNE                                        //bit10: TX事件FIFO新元素进入中断使能
    
63.                                         // |FDCAN_IE_TFEE                                        //bit09: TXFIFO空中断使能
    6 D9 i7 K' a* f% K# g# h+ t
64.                                         // |FDCAN_IE_TCFE                                        //bit08: 发送取消完成中断使能
    ; {7 w+ t2 {, V9 ]  Z+ [" p/ ~
65.                                         // |FDCAN_IE_TCE                                        //bit07: 传输完成中断使能
    9 c* m2 Y4 d; g- p% h$ J- ~% T
66.                                         // |FDCAN_IE_HPME                                        //bit06: 高优先级消息中断使能
    
67.                                         // |FDCAN_IE_RF1LE                                        //bit05: RXFIFO1报文丢失中断使能
    
68.                                         // |FDCAN_IE_RF1FE                                        //bit04: RXFIFO1消息满中断使能
    $ Y2 N1 Y1 R) x/ A# A
69.                                         |FDCAN_IE_RF1NE                                        //bit03: RXFIFO1新消息中断使能
    
70.                                         // |FDCAN_IE_RF0LE                                        //bit02: RXFIFO0报文丢失中断使能
    
71.                                         // |FDCAN_IE_RF0FE                                        //bit01: RXFIFO0消息满中断使能
    
72.                                         |FDCAN_IE_RF0NE                                        //bit00: RXFIFO0新消息中断使能
    
73.                                         ;
    
74.         FDCAN1->ILE = 0x00000000
    , p# j7 J9 \7 e6 r8 H) b; z
75.                                         |FDCAN_ILE_EINT1                                        //bit01: 中断总线 fdcan_intr1_it 使能
    " q. B/ g- M0 x( p# z" W% o& x2 s* g
76.                                         |FDCAN_ILE_EINT0                                        //bit00: 中断总线 fdcan_intr0_it 使能
    6 J0 x# @/ ^6 o! M$ k: o. [/ ]
77.                                         ;
    
78.         FDCAN1->ILS = 0x00000000                                                //中断总线选择
    
79.                                         // |FDCAN_ILS_PERR                                //bit06:
    
80.                                                                                                                 // ARAL: Access to reserved address line
    ) o0 a% e' @3 F* z# G" Z
81.                                                                                                                 // PEDL: Protocol error in data phase line
    * ^8 L- Z4 `% j$ E! l" n& `
82.                                                                                                                 // PEAL: Protocol error in arbitration phase line
    
83.                                                                                                                 // WDIL: Watchdog interrupt line
    
84.                                                                                                                 // BOL: Bus_Off status
    1 H) v( N( }1 w. |& q3 W
85.                                                                                                                 // EWL: Warning status interrupt line
    # ]3 \2 i# y* p, |& ?5 O
86.                                         // |FDCAN_ILS_BERR                                //bit05:
    8 {2 |  D% i: b/ }: e$ t- K( _
87.                                                                                                                 // ELOL: Error logging overflow interrupt line
    9 b" F5 F: T  O
88.                                         // |FDCAN_ILS_MISC                                //bit04:
    & k: {5 A  y: C& H- M! I# q/ Z
89.                                                                                                                 // TOOL: Timeout occurred interrupt line
    
90.                                                                                                                 // MRAFL: Message RAM access failure interrupt line
    & x: P, D4 h- h+ [* v
91.                                                                                                                 // TSWL: Timestamp wraparound interrupt line
    , T. Z$ y4 F8 u' j! }
92.                                         // |FDCAN_ILS_TFERR                                //bit03:
    & b8 l  c1 v8 g) E! L! ~
93.                                                                                                                 // TEFLL: Tx event FIFO element lost interrupt line
    8 n/ E: ]; \8 L; O$ f/ m/ X  I
94.                                                                                                                 // TEFFL: Tx event FIFO full interrupt line
    + x% |8 H9 |  P; d3 r( V
95.                                                                                                                 // TEFNL: Tx event FIFO new entry interrupt line
    1 G2 U( J. W0 b
96.                                                                                                                 // TFEL: Tx FIFO empty interrupt line
    
97.                                         // |FDCAN_ILS_SMSG                                //bit02:
    
98.                                                                                                                 // TCFL: Transmission cancellation finished interrupt line
    
99.                                                                                                                 // TCL: Transmission completed interrupt line
    . }( X# A4 `3 ~, V! X) V8 i: d+ ~
100.                                                                                                                 // HPML: High-priority message interrupt line
     , }) W8 q; T6 q9 A
101.                                         |FDCAN_ILS_RXFIFO1                                //bit01:当邮箱1的事件在 fdcan1_intr1_it 中断分支中处理
     
102.                                                                                                                 // RF1LL: Rx FIFO 1 message lost interrupt line
     
103.                                                                                                                 // RF1FL: Rx FIFO 1 full Interrupt line
     4 i  i+ X. N  L1 l
104.                                                                                                                 // RF1NL: Rx FIFO 1 new message interrupt line
     
105.                                         // |FDCAN_ILS_RXFIFO0                        //bit00:当邮箱0的事件在 fdcan1_intr0_it 中断分支中处理
     
106.                                                                                                                 // RF0LL: Rx FIFO 0 message lost interrupt line
     9 f4 y3 T( _+ Q5 K6 j9 S  @
107.                                                                                                                 // RF0FL: Rx FIFO 0 full interrupt line
     
108.                                                                                                                 // RF0NL: Rx FIFO 0 new message interrupt line
     8 i  \  ?. x, A* @1 ]
109.                                         ;
     5 n+ `0 N2 M; U+ w; \0 }0 E" s) h
110.         //步骤9 结束
     7 \, _' }. W! q
111. 
     
112.         //步骤10 使能筛选器
     
113.         FDCAN1->RXGFC |= 0
     , j9 [; G- i. k& @2 R0 ]$ ~3 T& J
114.                                         |(1 << FDCAN_RXGFC_LSE_Pos)                //bit[27:24]: 列表信息拓展【0|无拓展消息过滤】【1|1~8拓展消息】【>8|被解释为8】
     
115.                                         |(2 << FDCAN_RXGFC_LSS_Pos)                //bit[20:16]: 【0|无标准消息ID过滤】【1~28|标准消息ID元素过滤数量】【>28|被解释为28】
     " u6 j4 o! n  l* W7 B# B
116.                                         // |FDCAN_RXGFC_F0OM                                //bit09: FIFO0模式：覆盖或者堵塞【0|阻塞模式】【1|覆盖模式】
     4 W; ^3 s2 U& ]4 C. J% Q
117.                                         // |FDCAN_RXGFC_F1OM                                //bit08: FIFO1模式：覆盖或者堵塞【0|阻塞模式】【1|覆盖模式】
     
118.                                         |(2 << FDCAN_RXGFC_ANFS_Pos)        //bit[05:04]: 定义如何处理接收到的id为11位且与筛选器列表中的任何元素不匹配的消息。【0|在FIFO0中接收】【1|在FIFO1中接收】【2~3|拒绝】
     ) {" {) w8 u. M/ x
119.                                         |(2 << FDCAN_RXGFC_ANFE_Pos)        //bit[03:02]: 定义如何处理接收到的id为29位且与筛选器列表中的任何元素不匹配的消息。【0|在FIFO0中接收】【1|在FIFO1中接收】【2~3|拒绝】
     
120.                                         |FDCAN_RXGFC_RRFS                                //bit01: 【1|拒绝所有11位ID远程标准帧】
     
121.                                         |FDCAN_RXGFC_RRFE                                //bit00: 【1|拒绝所有29位ID远程标准帧】
     
122.                                         ;
     + n4 k& g1 q  z: O
123.         // FDCAN1->XIDAM = 0x1FFFFFFF;                                                //FDCAN 扩展 ID 和屏蔽寄存器
     # z& O- W/ i4 r+ {) u& K
124.         // FDCAN1->TXBTIE = 0
     . Q; o" j9 n4 g1 {/ O
125.         //                                 // |0x00000004                                                //bit02: TxBuffer【1|发送中断使能】
     9 v7 @- e& ]$ v/ _. u7 T/ Z
126.         //                                 // |0x00000002                                                //bit01: TxBuffer【1|发送中断使能】
     
127.         //                                  |0x00000001                                                //bit00: TxBuffer【1|发送中断使能】
     
128.         //                                 ;
     # y- k: }- g; N0 i% T* Z
129.         // FDCAN1->TXBCIE = 0
     
130.         //                                 // |0x00000004                                                //bit02: TxBuffer【1|取消中断使能】
     ) ?0 L7 N/ S/ L# o+ C
131.         //                                 // |0x00000002                                                //bit01: TxBuffer【1|取消中断使能】
     ) Z5 [$ c  [* H6 B- C
132.         //                                 // |0x00000001                                                //bit00: TxBuffer【1|取消中断使能】
     
133.         //                                 ;
     ) B* Y+ ]2 G0 M) F' z( i# L( r3 Q3 ]
134.         //步骤11 配置筛选器
     3 d- o+ [7 ~5 E  r
135.         FDCAN1_RAM->FILTER_11BIT[0] = 0x00000000
     
136.                                                                 |(1 << FDCANx_RAM_FILTER11_S0_SFT_Pos)                                //【0|范围过滤，从SFID1~SFID2】【1|单独滤波SFID1和SFID2】【2|经典滤波】【3|禁用过滤】
     
137.                                                                 |(1 << FDCANx_RAM_FILTER11_S0_SFEC_Pos)                                //【0|禁用过滤元件】【1|匹配存储在FIFO0】【2|匹配存储在FIFO1】【3|匹配存就拒绝】【4|匹配设置优先级】【5|匹配设置优先级并存储到FIFO0中】【6|匹配设置优先级并存储到FIFO1中】【7|保留】
     
138.                                                                 |(0x600 << FDCANx_RAM_FILTER11_S0_SFID1_Pos)                //【SFID1】
     
139.                                                                 |(0x609 << FDCANx_RAM_FILTER11_S0_SFID2_Pos)                //【SFID2】
     
140.                                                                 ;//列表滤波，只接收 ID为0x600和0x609 的数据，并且这两个ID放入FIFO0中
     
141.         FDCAN1_RAM->FILTER_11BIT[1] = 0x00000000
       k) D, B1 B) S. \2 W
142.                                                                 |(1 << FDCANx_RAM_FILTER11_S0_SFT_Pos)                                //【0|范围过滤，从SFID1~SFID2】【1|单独滤波SFID1和SFID2】【2|经典滤波】【3|禁用过滤】
       ], d9 ?! z$ a, m) p  U# u; d
143.                                                                 |(2 << FDCANx_RAM_FILTER11_S0_SFEC_Pos)                                //【0|禁用过滤元件】【1|匹配存储在FIFO0】【2|匹配存储在FIFO1】【3|匹配存就拒绝】【4|匹配设置优先级】【5|匹配设置优先级并存储到FIFO0中】【6|匹配设置优先级并存储到FIFO1中】【7|保留】
     
144.                                                                 |(0x209 << FDCANx_RAM_FILTER11_S0_SFID1_Pos)                //【SFID1】
     1 G) q) |3 e+ ^+ z
145.                                                                 |(0x209 << FDCANx_RAM_FILTER11_S0_SFID2_Pos)                //【SFID2】
     
146.                                                                 ;//列表滤波，只接收 ID为0x209 的数据，并且这个ID放入FIFO1中
     ) Y2 D- B; C, w# k+ K
147. 
     
148.         FDCAN1_RAM->FILTER_29BIT[0][0] = 0x00000000
     
149.                                                                         |(1 << FDCANx_RAM_FILTER29_F0_EFEC_Pos)                                //【0|禁止滤波】【1|匹配就保存FIFO1中】【2|匹配就保存FIFO2中】【3|拒绝匹配ID】【4|如果过滤器匹配，则设置优先级】【5|如果过滤器匹配，则设置优先级并存储在 FIFO 0 中】【6|如果过滤器匹配，则设置优先级并存储在 FIFO 1 中】【7|Reserve】
     # D  K1 k1 P1 S( B, a2 `
150.                                                                         |(0x0CCCCCCC << FDCANx_RAM_FILTER29_F0_EFID1_Pos)        //【EFID1】
     + U0 [4 f3 j" e# X1 ?
151.                                                                         ;
     * `4 q; f) M# I+ @- |' d) U
152.         // FDCAN1_RAM->FILTER_29BIT[0][1] = 0x00000000
     
153.         //                                                                 |(1 << FDCANx_RAM_FILTER29_F1_EFTI_Pos)                                //【0|EFID1到EFID2(EFID2>=EFID1)】【1|单独SFID1或者SFID2】【2|经典滤波】【3|EFID1到EFID2(EFID2>=EFID1),未使用XIDAM寄存器的掩码】
     ! l! W/ j9 a& y  Y6 \
154.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F1_EFID2_Pos)        //【EFID2】
     
155.         //                                                                 ;
     
156.         // FDCAN1_RAM->FILTER_29BIT[1][0] = 0x00000000
     
157.         //                                                                 |(1 << FDCANx_RAM_FILTER29_F0_EFEC_Pos)                                //【0|禁止滤波】【1|匹配就保存FIFO1中】【2|匹配就保存FIFO2中】【3|拒绝匹配ID】【4|如果过滤器匹配，则设置优先级】【5|如果过滤器匹配，则设置优先级并存储在 FIFO 0 中】【6|如果过滤器匹配，则设置优先级并存储在 FIFO 1 中】【7|Reserve】
     : N, O5 _) r  c" ~& X) _
158.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F0_EFID1_Pos)        //【EFID1】
     9 q5 G0 b9 F  k& R7 |$ H5 ^
159.         //                                                                 ;
     & Q8 D' j% v, f# Y. P0 W
160.         // FDCAN1_RAM->FILTER_29BIT[1][1] = 0x00000000
     
161.         //                                                                 |(1 << FDCANx_RAM_FILTER29_F1_EFTI_Pos)                                //【0|EFID1到EFID2(EFID2>=EFID1)】【1|单独SFID1或者SFID2】【2|经典滤波】【3|EFID1到EFID2(EFID2>=EFID1),未使用XIDAM寄存器的掩码】
     . M  {; i* ~+ B+ E, T6 m( H
162.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F1_EFID2_Pos)        //【EFID2】
     
163.         //                                                                 ;
     
164.         // FDCAN1_RAM->FILTER_29BIT[2][0] = 0x00000000
     & {: z- c; Q/ N' ^( c2 l& T
165.         //                                                                 |(1 << FDCANx_RAM_FILTER29_F0_EFEC_Pos)                                //【0|禁止滤波】【1|匹配就保存FIFO1中】【2|匹配就保存FIFO2中】【3|拒绝匹配ID】【4|如果过滤器匹配，则设置优先级】【5|如果过滤器匹配，则设置优先级并存储在 FIFO 0 中】【6|如果过滤器匹配，则设置优先级并存储在 FIFO 1 中】【7|Reserve】
     9 A. y( a9 g7 B4 ~. h0 a( ?4 G
166.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F0_EFID1_Pos)        //【EFID1】
     2 \* y/ P1 @& T: E4 O
167.         //                                                                 ;
     
168.         // FDCAN1_RAM->FILTER_29BIT[2][1] = 0x00000000
     
169.         //                                                                 |(1 << FDCANx_RAM_FILTER29_F1_EFTI_Pos)                                //【0|EFID1到EFID2(EFID2>=EFID1)】【1|单独SFID1或者SFID2】【2|经典滤波】【3|EFID1到EFID2(EFID2>=EFID1),未使用XIDAM寄存器的掩码】
     . e- e9 N2 e) A2 `- ^9 U5 B8 i1 y
170.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F1_EFID2_Pos)        //【EFID2】
     
171.         //                                                                 ;
     
172. 
     * _, J* l  l5 o6 q2 t, J, x
173.         // FDCAN1_RAM->FILTER_29BIT[3][0] = 0x00000000
     : E; n) K0 R/ X: e
174.         //                                                                 |(2 << FDCANx_RAM_FILTER29_F0_EFEC_Pos)                                //【0|禁止滤波】【1|匹配就保存FIFO1中】【2|匹配就保存FIFO2中】【3|拒绝匹配ID】【4|如果过滤器匹配，则设置优先级】【5|如果过滤器匹配，则设置优先级并存储在 FIFO 0 中】【6|如果过滤器匹配，则设置优先级并存储在 FIFO 1 中】【7|Reserve】
     % w3 K2 u( b  f, f9 W) H
175.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F0_EFID1_Pos)        //【EFID1】
     
176.         //                                                                 ;
     
177.         // FDCAN1_RAM->FILTER_29BIT[3][1] = 0x00000000
     
178.         //                                                                 |(1 << FDCANx_RAM_FILTER29_F1_EFTI_Pos)                                //【0|EFID1到EFID2(EFID2>=EFID1)】【1|单独SFID1或者SFID2】【2|经典滤波】【3|EFID1到EFID2(EFID2>=EFID1),未使用XIDAM寄存器的掩码】
     
179.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F1_EFID2_Pos)        //【EFID2】
     
180.         //                                                                 ;
     & l6 s- f3 @8 m/ ?6 V
181.         // FDCAN1_RAM->FILTER_29BIT[4][0] = 0x00000000
     3 e3 F* H$ y" |- b
182.         //                                                                 |(2 << FDCANx_RAM_FILTER29_F0_EFEC_Pos)                                //【0|禁止滤波】【1|匹配就保存FIFO1中】【2|匹配就保存FIFO2中】【3|拒绝匹配ID】【4|如果过滤器匹配，则设置优先级】【5|如果过滤器匹配，则设置优先级并存储在 FIFO 0 中】【6|如果过滤器匹配，则设置优先级并存储在 FIFO 1 中】【7|Reserve】
     6 H1 o3 A2 a* t
183.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F0_EFID1_Pos)        //【EFID1】
     
184.         //                                                                 ;
     
185.         // FDCAN1_RAM->FILTER_29BIT[4][1] = 0x00000000
     , I# f. V' B5 x$ b
186.         //                                                                 |(1 << FDCANx_RAM_FILTER29_F1_EFTI_Pos)                                //【0|EFID1到EFID2(EFID2>=EFID1)】【1|单独SFID1或者SFID2】【2|经典滤波】【3|EFID1到EFID2(EFID2>=EFID1),未使用XIDAM寄存器的掩码】
     2 R" {% l3 m0 r$ z/ c
187.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F1_EFID2_Pos)        //【EFID2】
     0 [4 E2 A: v- R3 @! C; F
188.         //                                                                 ;
     
189. 
     " j" p: @4 b" d2 F* P) G2 @
190.         //步骤12 清除INIT标志位
     ( K9 r' v" O( O3 s, s( g9 d. _
191.         FDCAN1->CCCR &= ~FDCAN_CCCR_INIT;//退出初始化模式，CCE会自动清除
     3 J- j1 B7 d  G$ U! G+ _
192.         while (FDCAN1->CCCR & FDCAN_CCCR_INIT);//等待退出
     
193. }

复制代码

附录2 发送函数
; Z! q/ t' k$ a6 e$ x返回第8章 发送操作

1. /**
   $ ~+ z3 M! x) L4 l" O: N" M
2. * @description: 发送11位地址的报文
   " Q# u7 y% M) C  \  [+ g8 G6 m
3. * @param {uint8_t} FDCAN_Index                FDCANx 1~3 FDCAN外设索引使用FDCAN1/2/3
   2 y) d4 G" c( X/ z+ T
4. * @param {uint16_t} ID                                11位ID发送
   5 B. e4 Z2 R0 w& }! V0 Z
5. * @param {uint8_t} RTR                                0-数据帧        1-远程帧
   
6. * @param {uint8_t} DLC                                数据长度 0~8
   
7. * @param {Buffer_72Byte_Struct}         *buffer 发送数组地址
   8 ]) G9 X1 S( r; V& ?1 x9 s
8. * @return {uint8_t}                                SUCCEED/FAILED/ERROR
   
9. * @author: XL
   # R- |" m! Y. M- n, e# @: z
10. */
    8 p7 C6 s% o" Y
11. uint8_t FDCAN_11ID_SendData(uint8_t FDCAN_Index, uint16_t ID,uint8_t RTR,uint8_t DLC,Buffer_72Byte_Struct *buffer)
    * H2 ]+ _, B5 h. _! F* l* r& [  U% q
12. {
    
13.         uint8_t Free_Mailbox;//空闲邮箱索引
    / `" A7 F/ H: K" H; ^9 [/ M
14.         FDCAN_RAM_Struct* FDCAN_RAM;//FDCANx_RAM指针
    
15.         FDCAN_GlobalTypeDef* FDCAN;//FDCANx指针
    
16.         switch (FDCAN_Index)//根据索引确定使用FDCANx
    * q+ b0 C- I1 d5 S4 A
17.         {
    
18.         case 1:
    $ j. T# ~% I* R9 n, n) W9 {% D$ H* ?
19.                 FDCAN_RAM = FDCAN1_RAM;
    ; }# k* y# C  q8 l' v
20.                 FDCAN = FDCAN1;
    
21.                 break;
    
22.         case 2:
    
23.                 FDCAN_RAM = FDCAN2_RAM;
    
24.                 FDCAN = FDCAN2;
    6 a' x* p% C* Y0 c4 v
25.                 break;
    
26.         case 3:
    
27.                 FDCAN_RAM = FDCAN3_RAM;
    
28.                 FDCAN = FDCAN3;
    
29.                 break;
    
30.         default:
    
31.                 return ERROR;//输入索引错误，无效
    - X) K' m; e( U& O, b
32.                 break;
    
33.         }
    
34.         if(FDCAN->TXFQS & FDCAN_TXFQS_TFQF)
    ' g$ e( e+ Q# p4 o% y' F
35.         {                                                                                        //CanBus判断是否有空闲的发送寄存器，然后发送，否则等待
      M# `& [& `7 p7 a0 ~
36.                 return FAILED;//没有空闲邮箱
    ! r, v! e. w& e* U8 [
37.         }
    
38.         else
    * T! n  J# v+ k- }& ^
39.         {                                                                                        //只要第一个邮箱空闲，始终先使用第一个，然后是第二个，第三个邮箱
    / Z1 Y' d+ {% s* S( }
40.                 Free_Mailbox = ((uint8_t)(FDCAN->TXFQS >> 16)) & 0x03;//获取空闲邮箱
    
41.                 FDCAN_RAM->Tx_BUFFER[Free_Mailbox][0] = ((uint32_t)ID << FDCANx_RAM_TxBuffer_T0_11ID_Pos);//写入地址
    & Z0 q/ {2 T: s4 s! i7 p
42.                 FDCAN_RAM->Tx_BUFFER[Free_Mailbox][1] = (DLC << FDCANx_RAM_TxBuffer_T1_DLC_Pos);//发送长度
      I& U: S% P. w% g( T. w* ~0 x
43.                 FDCAN_RAM->Tx_BUFFER[Free_Mailbox][2] = buffer->DataWord[0];//发送的数据
    4 q6 d9 U" {$ @2 y3 v5 d
44.                 FDCAN_RAM->Tx_BUFFER[Free_Mailbox][3] = buffer->DataWord[1];//发送的数据
    ' O5 @% [# f5 [
45.                 FDCAN->TXBAR |= (0x0001 << Free_Mailbox);//置位发送请求
    
46.                 return SUCCEED;//返回成功
    
47.         }
    
48. }

复制代码

& N; S+ p  P, W" b: W" Y附录3 接收中断程序
0 `9 N) T# Z2 Z# A
( F3 M- U6 J3 o6 W( v* T  k

1. /**
   & p( ^3 M- m, M7 v- c( l7 V
2. * @description: fdcan1_intr0_it 中断分支
   9 e& B, V' ^- a6 l+ E' U3 ]
3. * @param {*}
   
4. * @return {*}
   ' ~4 ?" b( r: |" d) ?7 F5 g
5. * @author: XL
   1 G9 s8 ^- D- z* R1 [# ]4 J
6. */
   
7. void FDCAN1_IT0_IRQHandler(void)
   
8. {
   * V1 b6 _1 x2 {
9.         if(FDCAN1->IR & FDCAN_IR_RF0N)//邮箱0有新消息
   / d8 a# ^1 _' g( W7 d
10.         {
    
11.                 FDCAN1->IR |= FDCAN_IR_RF0N;//清除新消息状态标志
    ! {$ r- h* Q; j% U; g* t2 z
12.                 switch((FDCAN1->RXF0S & FDCAN_RXF0S_F0GI) >> FDCAN_RXF0S_F0GI_Pos)//获取索引
    
13.                 {
    
14.                         case 0:
    $ |- A. o4 l; J$ R! M% L
15.                                 FDCAN1_Rxbuffer0.DataWord[0] = FDCAN1_RAM->Rx_FIFO_0[0][0];//获取数据
    
16.                                 FDCAN1_Rxbuffer0.DataWord[1] = FDCAN1_RAM->Rx_FIFO_0[0][1];//获取数据
    / G- ^( V" L( K" h
17.                                 FDCAN1_Rxbuffer0.DataWord[2] = FDCAN1_RAM->Rx_FIFO_0[0][2];//获取数据
      k5 K# n4 ^" M, f: T5 `. d: g
18.                                 FDCAN1_Rxbuffer0.DataWord[3] = FDCAN1_RAM->Rx_FIFO_0[0][3];//获取数据
    
19.                                 FDCAN1->RXF0A = 0;//确认接收完毕
    1 F; L. J* P8 E/ V4 ~1 a
20.                                 break;
    
21.                         case 1:
    
22.                                 FDCAN1_Rxbuffer0.DataWord[0] = FDCAN1_RAM->Rx_FIFO_0[1][0];
    2 D1 E& |0 t7 c9 V/ @
23.                                 FDCAN1_Rxbuffer0.DataWord[1] = FDCAN1_RAM->Rx_FIFO_0[1][1];
    
24.                                 FDCAN1_Rxbuffer0.DataWord[2] = FDCAN1_RAM->Rx_FIFO_0[1][2];
    + N9 {$ f' `5 m
25.                                 FDCAN1_Rxbuffer0.DataWord[3] = FDCAN1_RAM->Rx_FIFO_0[1][3];
    # T% v% a7 ]+ W: o
26.                                 FDCAN1->RXF0A = 1;
    
27.                                 break;
    / n. C4 {7 ^$ W0 C* F( J
28.                         case 2:
    
29.                                 FDCAN1_Rxbuffer0.DataWord[0] = FDCAN1_RAM->Rx_FIFO_0[2][0];
    4 {  `$ ]" H  A/ ~' ^( Q. U3 a
30.                                 FDCAN1_Rxbuffer0.DataWord[1] = FDCAN1_RAM->Rx_FIFO_0[2][1];
    
31.                                 FDCAN1_Rxbuffer0.DataWord[2] = FDCAN1_RAM->Rx_FIFO_0[2][2];
    
32.                                 FDCAN1_Rxbuffer0.DataWord[3] = FDCAN1_RAM->Rx_FIFO_0[2][3];
    
33.                                 FDCAN1->RXF0A = 2;
    
34.                                 break;
    " J, Y% R8 s7 b8 V
35.                         default:break;
    : G$ D% o3 n, v! X3 y& X
36.                 }
    ' Z; m8 u  Y& @1 e
37.         }
    * X+ \* [& b: Q
38. }
    
39. 
    
40. /**
    + w, L: R1 ~% O5 D- }* h
41. * @description: fdcan1_intr1_it 中断分支
    . i) L1 F8 {) a3 F+ s" @3 [6 X
42. * @param {*}
    
43. * @return {*}
    
44. * @author: XL
    ' e# P& S% _* n  c! o1 G3 I0 k8 ~
45. */
    , P- k$ L. ~4 F) @- L' \' i) U/ V
46. void FDCAN1_IT1_IRQHandler(void)
    
47. {
    + o) ~1 T9 D6 m3 q) D& B+ j! U
48.         if(FDCAN1->IR & FDCAN_IR_RF1N)//邮箱1有新消息
    
49.         {
    
50.                 FDCAN1->IR |= FDCAN_IR_RF1N;//清除新消息状态标志
    
51.                 switch((FDCAN1->RXF1S & FDCAN_RXF1S_F1GI) >> FDCAN_RXF1S_F1GI_Pos)//获取索引
    
52.                 {
    
53.                         case 0:
    
54.                                 FDCAN1_Rxbuffer1.DataWord[0] = FDCAN1_RAM->Rx_FIFO_1[0][0];//获取数据
    
55.                                 FDCAN1_Rxbuffer1.DataWord[1] = FDCAN1_RAM->Rx_FIFO_1[0][1];//获取数据
    
56.                                 FDCAN1_Rxbuffer1.DataWord[2] = FDCAN1_RAM->Rx_FIFO_1[0][2];//获取数据
    
57.                                 FDCAN1_Rxbuffer1.DataWord[3] = FDCAN1_RAM->Rx_FIFO_1[0][3];//获取数据
    7 p5 d2 ]4 U" y8 o& f' j! W
58.                                 FDCAN1->RXF1A = 0;//确认接收完毕
    % a$ d% h4 M$ [! r. M
59.                                 break;
    
60.                         case 1:
    
61.                                 FDCAN1_Rxbuffer1.DataWord[0] = FDCAN1_RAM->Rx_FIFO_1[1][0];
    % r" C9 n5 y4 l: E8 [
62.                                 FDCAN1_Rxbuffer1.DataWord[1] = FDCAN1_RAM->Rx_FIFO_1[1][1];
    ! v  S7 \& o! u& Z# B" m( n
63.                                 FDCAN1_Rxbuffer1.DataWord[2] = FDCAN1_RAM->Rx_FIFO_1[1][2];
    # }5 e/ ~+ _' }2 z
64.                                 FDCAN1_Rxbuffer1.DataWord[3] = FDCAN1_RAM->Rx_FIFO_1[1][3];
    - u1 M9 C4 {" N' E8 K- M* W8 w
65.                                 FDCAN1->RXF1A = 1;
    ( G9 g- R# A( A- _. v1 Z+ `
66.                                 break;
    
67.                         case 2:
    
68.                                 FDCAN1_Rxbuffer1.DataWord[0] = FDCAN1_RAM->Rx_FIFO_1[2][0];
    
69.                                 FDCAN1_Rxbuffer1.DataWord[1] = FDCAN1_RAM->Rx_FIFO_1[2][1];
    
70.                                 FDCAN1_Rxbuffer1.DataWord[2] = FDCAN1_RAM->Rx_FIFO_1[2][2];
    - l, f+ J( V, ?7 Y! e9 V
71.                                 FDCAN1_Rxbuffer1.DataWord[3] = FDCAN1_RAM->Rx_FIFO_1[2][3];
    9 G, k) i: v6 G  ], y8 Q& }0 A
72.                                 FDCAN1->RXF1A = 2;
    
73.                                 break;
    - ^' x% z. ~2 X  Y% d9 T
74.                         default:break;
    
75.                 }
    1 R6 n8 a8 D! Q, J5 @
76.         }
    2 A- T. p* a6 P( x3 x" k. [
77. }

复制代码

$ H) d$ t0 x& R+ w4 `, _- T9 Z————————————————
) Q; Q- U. K4 `! p版权声明：Vice Versa XL
" p7 U. d3 _& E/ a
0 Y. j: J1 K7 k9 A7 M/ \) r